<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by jon skulski on Medium]]></title>
        <description><![CDATA[Stories by jon skulski on Medium]]></description>
        <link>https://medium.com/@jonskulski?source=rss-700ecd04dc6e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*Dk33cdC2b7ZURQm4.jpeg</url>
            <title>Stories by jon skulski on Medium</title>
            <link>https://medium.com/@jonskulski?source=rss-700ecd04dc6e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 14:08:51 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jonskulski/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Field Report: Elm]]></title>
            <link>https://medium.com/@jonskulski/field-report-elm-3187d87dfb08?source=rss-700ecd04dc6e------2</link>
            <guid isPermaLink="false">https://medium.com/p/3187d87dfb08</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[elm-lang]]></category>
            <category><![CDATA[functional-programming]]></category>
            <category><![CDATA[elm]]></category>
            <dc:creator><![CDATA[jon skulski]]></dc:creator>
            <pubDate>Mon, 17 Oct 2016 15:56:01 GMT</pubDate>
            <atom:updated>2016-10-17T15:56:01.040Z</atom:updated>
            <content:encoded><![CDATA[<h3>Elm?</h3><p>In brief, Elm is a functional language from the ML-family that compiles to javascript to run in the browser. It is aimed at creating scalable web applications. Elm inspired parts of Redux. The mental models are very similar.</p><p>The community does a great job explaining itself at <a href="http://elm-lang.org/">http://elm-lang.org/</a></p><h3>My experience is brief, but I liked what I saw.</h3><p>I spent a couple days with Elm building the game ‘snake’. I find the game to be a good exercise for learning user input and events in a new language or tool. So I gave it a shot:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/854/1*7MRS8w_fR3oTjFmiY4MYSw.gif" /></figure><p>Success, sort of! I’m still working on it, but <a href="https://github.com/jskulski/snake-elm/blob/master/Main.elm">the code is available here</a>.</p><p>Elm is an exciting project. It has a lot of things going for it. Many of the technical aspects have been laid out by Mr. Rishi Goomar in his post “<a href="https://medium.com/@rgoomar/why-i-think-elm-is-the-future-of-front-end-development-21e9b091fa05#.ns0pjprhf">Why I think Elm is the Future of Front End Development</a>”.</p><p>I also see a lot of promise with Elm.</p><h3>Developer experience is a first class citizen</h3><p>My experience was that of fast feedback and minimal context switching. I was either looking at a compiler error or I was playing my game. <em>Even though, I just picked it up, I felt like I could make meaningful progress at each step.</em></p><p>I was shocked that the claim of “<em>no runtime exceptions</em>” was actually true. When I introduced behaviors I wasn’t expecting, it was because my mental model was wrong (row, column vs column, row etc). There wasn’t side-effect-y bugs.</p><p>Because of the bold claim, I skipped writing tests. I wanted to see how it held up.<em> No regressions.</em> Each time I added a feature it stayed there.</p><p><em>The compiler messages are detailed and accurate.</em> The only times I felt lost, I wasn’t reading the compiler message correctly. That’s the truth.</p><p>Shoutout to vscode and its elm plugin. Without configuration, these compiler messages start showing up as you write code without having to run a command or context switch to another window.</p><p><a href="https://www.youtube.com/watch?v=oYk8CKH7OhE">Elm has a stated goal to bring the benefits of functional programming to the masses</a>. Which <em>requires d</em>eveloper user experience is a first class citizen. Elm delivers on that.</p><h3>In the real world?</h3><p>Is Elm academic (yes) or can it be used in the real world? Great question! Here are some of my thoughts.</p><h4>Some companies are reporting big wins</h4><p><a href="http://futurice.com/blog/elm-in-the-real-world">Futurice reports their switch here.</a> No Red Ink has been loud about their use since adoption. The topic is discussed in the beginning of the following Q&amp;A Panel:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FLCNs92YQjhw%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DLCNs92YQjhw&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FLCNs92YQjhw%2Fhqdefault.jpg&amp;key=d04bfffea46d4aeda930ec88cc64b87c&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/62a78b1f83876ed089a88d71b8f745e8/href">https://medium.com/media/62a78b1f83876ed089a88d71b8f745e8/href</a></iframe><h4>Limits talent pool?</h4><p>A concern that I had was limiting the number of candidates to hire. Engineering teams need to grow, and if the pool of workers is small that can be a business problem. You have to either train or hire competitively. Interestingly enough, No Red Ink (in the video posted above) reports that after ‘being loud with their use of Elm’ <em>the quality of candidates skyrocketed.</em></p><p>Isn’t that incredible? Limiting your candidate pool and the number of people you want to hire increases?</p><p>I find that fascinating. Paul Graham talked about this in his article, <a href="http://paulgraham.com/pypar.html">The Python Paradox</a>. To me, it makes some clown sense. Great engineers want to work with great tooling, so they go to places where they can.</p><p>But <strong><em>this is only true for a very limited window of time. </em></strong>In reference to the article, on a long enough timeline, python is the new java.</p><h4>Similar to React/Redux</h4><p>Since Elm is essentially React/Redux enforced at the language level, I can see a team gaining a lot of productivity. It is the same tool with better and faster feedback that prevents anti-patterns, without limiting what you can build.</p><p>The cost of switching could be pretty low. I have built a few apps in react and redux so I had a few hours of ‘oh this is that’ and then I was off to the races. I’d imagine that would be similar for a team used to react/redux.</p><p>Of course, rewriting an app from react/redux to elm would make little business sense. There’s a number of tools to piece-meal change over a react app, including a React component that runs an Elm app. (Or vice versa) So you can work in chunks.</p><h4>Young language and has limited tooling</h4><p>Elm is still figuring itself out. For example, in the v0.17 they changed the naming of a central concept from ‘Action’ to ‘Msg’ (Message). A small change, but a main part of the mental model (of the Html.App part of the language). It’s good to get that stuff right, of course, but reveals youth.</p><p>The tooling is great but since the project is only 4 years old, tooling can be sparse. For example, I used VSCode which was a nice experience, but lacked proper syntax grammar files so I stared at lots of white text with blue variable names. That will get better with time.</p><h4>Getting stuck with Elm</h4><p>My biggest concern would be adopting Elm and it being ‘over’. And now you have a codebase in a <em>language</em> that nobody uses.</p><p>Now it’s open source and the spec exists, so you can always write your own toolchain. But for very sound reasons, most web application shops don’t want to support a language. So, let’s say that adoption would depend on continued community or big-facebook-style-company support.</p><p>So let’s just count this one as an all around risk. While the community is vibrant and active (5k chatting away in the slack, active meetups, a conference), it is young and small so there’s a chance this all goes away.</p><p>That said, I think there’s <strong>significant</strong> <strong>competitive advantage</strong> to a business whose engineering team can reliably deploy web apps without errors or regressions. And Elm promises that.</p><h4>Active friendly community</h4><p>I mentioned the community above, but I want to highlight how big of an asset this is. Communities are great indicators of adoption + success.</p><p>Again, my experience is limited, but I have found the community to be warm, helpful and active. The documentation and tutorials are thorough, the modules to choose are (mostly) obvious. Help on the slack channel was fruitful and and supportive. Both technical and design questions were fielded quickly and expertly. Thanks, everyone!</p><p>(PS If you’re in SF there is a <a href="http://www.meetup.com/Elm-user-group-SF/events/234016091/">regular hack night</a> this Wednesday. I’ll be there! Say hi!)</p><p>(PPS There is also <a href="https://docs.google.com/document/d/1qc3Rdbb3oAZnNd8gkgGgxnOSSu_aPV4fP5qojDCr8Tg/edit#">remote meet up</a> happening on Oct, 24th.)</p><h4>Conclusion</h4><p>I would like to try Elm out in a small app with a team to test these claims.</p><p>Currently, there’s not much incentive to move away from React/Redux. It works pretty well and <em>we sorta, uh, just got here, man</em>. There’s non-trivial risk in choosing Elm. So it doesn’t make sense to move to Elm wholesale. The push/pull thing doesn’t equal out. So that puts me in the camp of early adopter, and I’m okay with that. The benefits that could be gained are next-level.</p><p>With most of my time with Elm, I felt directed toward solutions and never stuck on problems. Feedback was instant, I never felt stuck. When I wanted to change the structure to fit the new problem, I just did it and returned the program to a working state.</p><p>Can you imagine the productivity of a whole team working with no runtime exceptions, minimal regressions and defect-free refactoring?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/467/1*pInKeEYPGpAzZdIJ8p9xdg.gif" /></figure><p>Happy building!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3187d87dfb08" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I confused choosing the wrong implementation and having no feedback]]></title>
            <link>https://medium.com/@jonskulski/i-confused-choosing-the-wrong-implementation-and-having-no-feedback-95dc85ef45f2?source=rss-700ecd04dc6e------2</link>
            <guid isPermaLink="false">https://medium.com/p/95dc85ef45f2</guid>
            <category><![CDATA[poetry]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[life-lessons]]></category>
            <dc:creator><![CDATA[jon skulski]]></dc:creator>
            <pubDate>Wed, 15 Jun 2016 15:29:08 GMT</pubDate>
            <atom:updated>2016-06-15T15:29:08.722Z</atom:updated>
            <content:encoded><![CDATA[<p>I was writing software the other day. And I had a choice between two implementations: PATH A and PATH B. Seemingly the same. No clear differences. I had an arguably arbitrary choice to make.</p><p>I chose PATH A. <br>I got to work and coded.<br>And I sat and thought. <br>Problems with the choice started arising <em>in my mind.</em> <br>Oh if I want FEATURE X to happen, then PATH A makes that hard.</p><p>Hmm, let me try PATH B. <br>I ditched code. <br>I got to work and coded.<br>And I sat and I thought.<br>Problems with the choice started arising <em>in my mind</em>. <br>If FEATURE Y was going to be needed, then PATH B makes THAT hard.</p><p>Then a third time, I doubted myself. <br>No, actually PATH A makes sense. <br>I ditched code.<br>I got to work and re-worked.<br>And I sat and I thought.<br>Doubt began to creep, but this time, the clouds parted and I was granted a brief moment of awareness.</p><p>I had never actually <em>ran</em> the program. I implemented paths but I had never gotten any feedback. Then it became clear. The doubt wasn’t centered around the implementation. I felt doubt and placed it on the implementation. It was a delusion. The doubt was because I never felt the joy of feedback. I never knew that any of the implementations worked. So of course I felt doubtful.</p><p>I wonder how many times <em>that’s happened.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=95dc85ef45f2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Duplication isn’t evil, it’s a balance.]]></title>
            <link>https://medium.com/@jonskulski/duplication-isn-t-evil-it-s-a-balance-9fa16f13864b?source=rss-700ecd04dc6e------2</link>
            <guid isPermaLink="false">https://medium.com/p/9fa16f13864b</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[jon skulski]]></dc:creator>
            <pubDate>Fri, 09 Oct 2015 16:23:11 GMT</pubDate>
            <atom:updated>2015-10-19T23:27:30.388Z</atom:updated>
            <content:encoded><![CDATA[<p>Exasperated Business Person:<em> “Shouldn’t that be easy? I’m asking for a single change.”</em></p><p>Exasperated Engineer: <em>“Right, yeah. It’s hard to explain but the Sorting framework is a really hairy layer, and then I have to remember to make changes in module A and B, and they’re really fragile…”</em></p><p>Duplication is what drives these conversations. Having to make a change in many different places is difficult. It’s hard to think about, hard to remember all the details. There’s a lot of risk. <em>It gums up your works, man!</em></p><p>On some scale, duplication is good. It makes the ecosystem diverse. <em>It’s a very good thing that there’s tools, frameworks, and languages to choose from.</em> I’ll make the case that local codebases aren’t an exception.</p><h4>One True Way</h4><p>I’ve seen codebases that insisted on One True ways. As soon as a concept or tool was chosen, it was crystalized as <em>The Right One-</em> to be used forever and always.</p><p>The upside is familiarity, any developer can sit down and already know how to interact with the system. The downside, was it has to make the system simpler. We couldn’t try different ways. We couldn’t even test if we needed that tool. The trade-off was Ease for Simplicity. The <a href="http://www.infoq.com/presentations/Simple-Made-Easy">Hickey’s epic Simple Made Easy talk explains</a> why that’s a poor trade-off.</p><p>I tend to favor multiple approaches. Sometimes when I don’t know the way forward, I’ll try out a few different approaches. I’ll reserve some hours at the end, to re-evaluate the solutions. Maybe I need to combine them to one. Maybe I don’t- sometimes making a few approaches can stop <a href="http://c2.com/cgi/wiki?PrematureAbstraction">Premature Abstraction</a>. I might be feeling uncertainty about solution because I’m sensing but not realizing that there are differing requirements. That one solution won’t work.</p><p>The time it takes for a developer to familiarize themselves with a new tool is a good price to pay for the ability to keep systems simple and agile.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9fa16f13864b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PyRoom Is Over, If I Want It]]></title>
            <link>https://medium.com/@jonskulski/pyroom-is-over-if-i-want-it-d751658d085?source=rss-700ecd04dc6e------2</link>
            <guid isPermaLink="false">https://medium.com/p/d751658d085</guid>
            <dc:creator><![CDATA[jon skulski]]></dc:creator>
            <pubDate>Sun, 21 Jun 2015 06:03:11 GMT</pubDate>
            <atom:updated>2015-06-21T06:03:11.476Z</atom:updated>
            <content:encoded><![CDATA[<p>I finished pulling most GUI concerns out of the ‘Editor’ object. Unit tests now run without having to launch 35+ GUIs that it wasn’t testing.</p><p>It was a white whale sort of situation. I’ve been intrigued with how to test GUI desktop applications. Sometimes it gets very tangle-y, and the edges between what is interface and what is application blur. It’s hard to separate.</p><p>I feel successful. I carved enough away that I can see that the Editor object’s real purpose: coordinating buffers and mapping keystrokes to commands. I can see how I would move forward and that’s enough for now.</p><p>I feel like this is incredibly true with javascript web applications. Maybe its the ecosystem, or the closeness of JS and the DOM.</p><p>I’ll put a few more commit efforts into PyRoom, but that is all. It’s got creaky bones and I’m satisfied that I refactored it enough so I can conceivably see the path to replace the GUI with PyGL or something more modern. But, it’s time to move on.</p><p>I have some work in web coming up so I’m going to take a look at building the next generation on the web.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d751658d085" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spies in Python]]></title>
            <link>https://medium.com/@jonskulski/spies-in-python-6fd89945ea6b?source=rss-700ecd04dc6e------2</link>
            <guid isPermaLink="false">https://medium.com/p/6fd89945ea6b</guid>
            <dc:creator><![CDATA[jon skulski]]></dc:creator>
            <pubDate>Fri, 12 Jun 2015 21:04:32 GMT</pubDate>
            <atom:updated>2015-06-12T21:53:52.375Z</atom:updated>
            <content:encoded><![CDATA[<p>I’m doing testing (sensing) on my editor and GUI in Pyroom. The GUI is very coupled and used everywhere. Creating a full mock GUI was proving to be difficult and drudgery, since it was called in so many places, in so many ways.</p><p>Since the beginning, I’m relying on integration tests. For the majority, if not all, my tests, I’m creating a full GUI. That’s taking a long time and something I’m looking forward to getting rid off.</p><p>However, I can’t get full inject a mock GUI until I’m separated enough of it. But I need (want? should?) tests in place to make sure I’m not breaking anything.</p><p>So I’ve turned to creating full GUI elements and monkey-patching in spies where I need them.</p><h4>Simple Spy Solution</h4><p>I couldn’t find a library that worked (kgb looked simple but it complained that a gtk function had no ‘func_name’ attr. I couldn’t figure that out in 15 minutes, and seemed deep enough to be hairy, so I looked into my own solution. Turned out there was a simple, readable and fun.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f7cf24edc93c9626d6a3d04352a4cf0e/href">https://medium.com/media/f7cf24edc93c9626d6a3d04352a4cf0e/href</a></iframe><p>And to use them:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/71b19df529388389e5c0cd9ecfa99563/href">https://medium.com/media/71b19df529388389e5c0cd9ecfa99563/href</a></iframe><p>It’s a low rent solution, but it does one thing very very well. Clearly there’s room to grow (if I need!) to check number of times called, parameter memory, etc. But for now it’s perfect.</p><p>I’m not deep into python, so I might be overlooking a more obvious solution. There were a few libraries, but they looked too heavy or didn’t work. And <a href="https://docs.python.org/3/library/unittest.mock.html">looks like there’s a wonderful python3 solution</a>. So there’s not a long life on this solution.</p><p>But so what? Software goes away. It changes. It gets deleted. It solves today problem. And it was satisfying to implement so simply and so close to the language.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6fd89945ea6b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Big Fonts]]></title>
            <link>https://medium.com/@jonskulski/i-like-big-fonts-727fb020a3bf?source=rss-700ecd04dc6e------2</link>
            <guid isPermaLink="false">https://medium.com/p/727fb020a3bf</guid>
            <dc:creator><![CDATA[jon skulski]]></dc:creator>
            <pubDate>Wed, 10 Jun 2015 20:09:45 GMT</pubDate>
            <atom:updated>2015-06-10T20:10:58.788Z</atom:updated>
            <content:encoded><![CDATA[<p>I work at 22px, sometimes more. I like it. I get asked if my eyes are good. They are, adequate at least. I choose big fonts because of an aesthetic from school. I like it because it increases my concentration and focus.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FrTU6dhJ0qhXm23TwxA6bw.png" /></figure><p>I’ve been digging stripping down as much visual clutter. The less on screen the easier it is to focus. Big, fat letters. Clear as day. Love it.</p><p>I used to dig this though:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RV8R9aLUr5_sOAn3TZ2K9w.jpeg" /></figure><p>Small fonts, cool looking apps and widgets and look how my CPU is doing oh network traffic log, etc.</p><p>Along with the aesthetic, I stopped digging the idea of slamming mountain dews in a dark room. It was difficult and physically exhausting, and there were more way more lows than highs. And it all came with an expiration date. I was always looking for other career options. There’s no way I could be doing that when I’d be 50.</p><p>It was an aesthetic that sapped my confidence and produced rickety software.</p><p>Over the last few years, my pace has steadied. I’ve found focusing on a breaking down problems and locking down the solutions provides a steady sense of progress.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/778/1*O_1sH0uW4Ejx-abg6ld1gQ.png" /></figure><p>I think the big fonts are the visual part of this shift. Having less screen real estate makes me economical about what I put in my visual field. Having less clutter helps me focus on the next step.</p><p>It was a nice shift. It makes me feel like there’s a future, and that I’m getting better, and that it’s not just a blaze of IQ points at a monitor. While IQ and effort are still a big part of the equation, relying only on them will not guarantee against poor software. Such reliance will almost certainly decrease quality. The element of experience and patience in software engineering has got me excited.</p><p>And now I can’t wait to be writing software at 50.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=727fb020a3bf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Instability!]]></title>
            <link>https://medium.com/@jonskulski/instability-6c36eb19c3b?source=rss-700ecd04dc6e------2</link>
            <guid isPermaLink="false">https://medium.com/p/6c36eb19c3b</guid>
            <dc:creator><![CDATA[jon skulski]]></dc:creator>
            <pubDate>Mon, 08 Jun 2015 18:02:41 GMT</pubDate>
            <atom:updated>2015-06-08T18:34:25.991Z</atom:updated>
            <content:encoded><![CDATA[<p><em>I’ve made PyRoom less good! Oh no!</em></p><p>It still generally works but actually using it for the first time in a couple days has been a bit disappointing. I can still write in it, I’m writing now, but autosave isn’t working and there was some issues with undo + save that I’ve now cleaned up.</p><p>I’m spending today catching bugs and writing tests and doing de-duplication tasks that I’ve been putting off. Clearly no sense in ‘refactoring’ a program that doesn’t solve a problem any more.</p><p>But I’ve been here before. I want to learn from it so I wrote some notes about how and why I’m here and how to get out.</p><h4>Causes and Notes</h4><p>It’s been simmering for the last couple days. Weird errors I’d push to the side, unexpected behaviour, crashing. Duplication I know I should have cleaned up.</p><p>Prior to my involvement, the codebase had a lot of side effects. For example, creating an `Editor` object would do the following (and more):</p><ul><li><strong>Create</strong> a `Config File Reader`</li><li><strong>Create</strong> a `Config` object</li><li><strong>Mutate</strong> Config object to defaults</li><li><strong>Examine</strong> home directory for a config file</li><li>If there’s a config file, <strong>mutate</strong> `Config` to those values</li><li>If not, <strong>write</strong> the config file</li><li><strong>Create</strong> a number of other objects, including a full GUI</li><li><strong>Return</strong> a new Editor object</li></ul><p>So it’s been a challenge to test things in isolation and to do so carefully. However, none of this is an excuse for instability.</p><p>It is totally, knowingly my fault. A few things that contributed to it:</p><ul><li><strong>Fatigue</strong>. I was tired and I continued working. Didn’t take breaks.</li><li><strong>Too long without eyes</strong>. Partly by design, partly by necessity, but decisions and willpower are mine. Meaning, assumptions aren’t caught and it is easy to slack off.</li><li>I started knowingly making moves that I wasn’t certain of. <strong>I took on too much risk</strong>. Certainly moves that I wouldn’t make if this was ‘production’.</li><li><strong>Lack of thorough testing</strong>. I started to assume a green test suite was good enough. I assumed tests were covering behaviours they weren’t.</li><li><strong>Stopped refactoring, started to rewrite</strong>. Not enough tests, just changin’ stuff.</li><li><strong>I stopped using the product</strong>. I wasn’t really writing or taking notes so I lost my most important test: <em>as a user I want the product to solve my problem and feel pleasurable to use</em>? This allowed several defects to stack to get to where we are.</li></ul><p>Basically, I wasn’t writing enough tests AND I relied to heavily on them because I wasn’t using PyRoom. Bad combo.</p><h4>No, no! Dig UP, stupid!</h4><p>A cab driver once said to me <em>“I don’t go in reverse. They tell us nothing good ever happens when you go backwards.”</em></p><p>I’ve always had a similar concept for software development. <em>Moving forward is should easy and fixing bugs so simple that moving backwards is less good than moving forward. </em>To do this requires releasing to be easy and frequent. It requires extensive and responsive test suite. It requires confidence in the system.</p><p>So I’ll try to follow that philosophy, here. I don’t really meet the requirements so it might be pushing me in the wrong direction, spinning my wheels. But I’ll try it for today. I think there’s a lot of my system that I’m foggy about. I think I can clear the bugs with tests and understanding.</p><p>The attack will be two-fold:</p><p>1) Use the program. That was the root before so let’s fix that right away. <em>I’m using it now (after some clean up earlier) and the experience seems much better</em></p><p>2) Writing acceptance tests around what’s not working, focusing on behaviour. For example, undo/redo broke at a high level. A sanity test to create editor with a buffer type words in, undo, see blank, redo, see words. Then dive in.</p><p>Off we go.</p><h4>Field Report</h4><p>I wrote that on Friday and it’s Monday now. I spent most of Friday fixing these bugs and all the fires seem to be put out. The editor is usable and all prior functionality has returned.</p><p>This feels like a lesson I already knew.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6c36eb19c3b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Refactoring is the Most Important Skill for a Software Engineer Today.]]></title>
            <link>https://medium.com/@jonskulski/refactoring-is-the-most-important-skill-for-a-software-engineer-today-a970867a35e0?source=rss-700ecd04dc6e------2</link>
            <guid isPermaLink="false">https://medium.com/p/a970867a35e0</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[refactoring]]></category>
            <dc:creator><![CDATA[jon skulski]]></dc:creator>
            <pubDate>Thu, 04 Jun 2015 21:38:30 GMT</pubDate>
            <atom:updated>2015-06-04T21:39:42.167Z</atom:updated>
            <content:encoded><![CDATA[<p>That’s my dumb opinion.</p><p>Like real refactoring. Refactoring defined as improving code structure without changing behaviour.</p><p>It takes discipline to verify I’m changing anything (<em>tests</em>) and to restrict myself to moves that are too dumb/simple to fail.</p><blockquote>“Without tests refactoring is just changing stuff” — Someone at some point.</blockquote><p>So I’m trying this out. Practice sort of. I forked an opensource project (Pyroom) with the aim of adding my own features by improving the code. I’ve mostly improved code so far.</p><p>I was surprised to find a program that I’ve loved to use so long to have a lot of poor code. I can see it had a strong great design in the beginning, but that was muddied.</p><p>I’ve tried to be fairly rigid. I’ve added tests, mostly acceptance tests, to anything I’m changing. I’m trying to stay as green as possible. You can checkout the progress at <a href="https://github.com/jskulski/PyRoom">https://github.com/jskulski/PyRoom</a>.</p><h4>Welcome to Nerdtown</h4><p>It’s satisfying to break objects apart. For example, when I first started anytime you created a (what will be known as the) Editor object, it would have a side effect of creating other objects, reading from your home directory, writing config files if not present, etc.</p><p>Through a fairly steady process, I was able to inject that config into the editor. This means that I can create editor objects will specific configurations, without having to wipe out my configuration for `production`, e.g. when I’m actually using PyRoom to write.</p><p>The GUI and Editor are still intricately linked though, right now. Though I did have progress yesterday after breaking most of the circular dependencies. Right now when I run my testsuite, my screen flashes like mad because 25 GUIs are being created and shut down. It only takes ~5 seconds so it’s not blocking progress at the moment. But it’s clearly a <em>hurdle, </em>and one that needs to go away.</p><p>And it’s a personal white whale I suppose. I’ve just come off a long project writing a mobile isomorphic javascript application. The seam between the GUI and application (state?) was always hard to find. So being able to break these apart will be enlightening.</p><p>CARRY ON MY WAYWARD SON</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a970867a35e0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Smalltalk and Development Environments]]></title>
            <link>https://medium.com/@jonskulski/smalltalk-and-development-environments-30389a3f3803?source=rss-700ecd04dc6e------2</link>
            <guid isPermaLink="false">https://medium.com/p/30389a3f3803</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[jon skulski]]></dc:creator>
            <pubDate>Thu, 04 Jun 2015 18:15:36 GMT</pubDate>
            <atom:updated>2015-06-05T09:02:53.479Z</atom:updated>
            <content:encoded><![CDATA[<p>I stumbled across <a href="http://pharo.org/">Pharo</a> the other day. It is a dialect of Smalltalk and this wonderful environment to create your app.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fvideoseries%3Flist%3DPL4actYd6bfnyYK1UzjlGxg4HWTljXI2Il&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DHOuZyOKa91o%26list%3DPL4actYd6bfnyYK1UzjlGxg4HWTljXI2Il&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FHOuZyOKa91o%2Fhqdefault.jpg&amp;key=d04bfffea46d4aeda930ec88cc64b87c&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/1c64c5d5ebcb0ddd3ca36d54a9ebfa17/href">https://medium.com/media/1c64c5d5ebcb0ddd3ca36d54a9ebfa17/href</a></iframe><p>I’m sure even 5 years ago I would be shuddering at the thought of using such a UI. I liked black and green and vim. Code was text and no one could shackle my creativity.</p><p>But today, this looks <em>exciting</em>. <em>Like</em> <em>cartoon dog seeing someone as a big steak exciting</em>. I long for an environment that <em>understands</em> the code as code, not text. I long for an editor that manipulate the abstract syntax tree.</p><h4>Smalltalktalk</h4><p>I don’t really know much about Smalltalk. I know that a lot of people I look up seem to like it: Martin Fowler, Kent Beck, et al. Even so much as to lament it’s waning from wide use, a gift too perfect to be appreciated by the status quo. An idea that the world isn’t ready for yet. <em>[ Edit: apparently there were a lot of licensing issues, issues with pricing, high bar of entry, etc. ]</em></p><p>I’m probably showing my youth here. I might be neglecting a direct ancestor that is standing right behind Smalltalk. But so it goes, it’s always like that. Yo dawg, giants standin’ on giants.</p><h4>IDES and Productivity</h4><p>From a brief search it looks like the Development environment was always a part of Smalltalk. I’m surprised, but not shocked, that this idea hasn’t caught on.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/255/1*ACOHwhS7k2W98pZ0uo_Qzw.jpeg" /><figcaption>Yum. A long history of semantic editing?</figcaption></figure><p>Little pieces make it through in IDEs. Refactor menus are necessary. Code generation is a must. Jump-navigation of code. REPLs and good documentation.</p><p>I’ve worked mostly with Python, Ruby and PHP over the last few years. The general dev environment is text based. The tools listed above, if implemented at all, are young and rudimentary. (I do love what Jetbrains is doing.) The tools seem immature. The communities are dismissive of IDEs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Iq1S8PkDAiPSpk5DhUv4cg.jpeg" /></figure><p>IDEs can feel slow and clunky and my god look at all this information overload. Personally, after using Jetbrain’s PHPStorm I got an experience of using an IDE that was light enough to let me see the powers of the refactor tool. It didn’t hurt that I was writing OO PHP, which can be very verboseb.</p><p>I could finally start treating the code like code instead of lines of text. It enabled me to confidently but simply improve the code base. I could rename variables, extract methods and classes, move methods around all while (mostly) ensuring the correctness of the system. I went back to Sublime for a few days for a project in Javascript and noticed instantly how I would start to extract a method manually then give up because I lost confidence in the system.</p><blockquote>Give me a refactor menu long enough, and I will move the world.</blockquote><p>If the IDE helps me keep the codebase clean then that’s productive.</p><h4>The Tool or the Artist</h4><p>It’s clear that a great artist can use any tool to produce great work. It’s also clear that using a ball point pen to illustrate a 20&#39;x20&#39; canvas will take an absurdly long time and all your willpower.</p><p>Ultimately, I don’t care what engineers use to produce code. But I do know it’s difficult when conceptualizing code as text on paper. The easiest programming language is arbitrary boxes and lines on whiteboards or in our heads. And the white-board-box-marker-lang compiles down to most of current languages, and then we throw out the white-board-box-marker-lang and spend 10 minutes of the next meeting drawing it on the board. Despite our love for rigor, surely there must be some way to capitalize on how easy it is to wire boxes.</p><p>I’m excited by the idea of tools guiding us through the process of writing software. Today, it’s a little too double, double, toil and trouble, fire burn cauldron bubble, did our tests pass? Are the ingredients comp’ble?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=30389a3f3803" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Focus.]]></title>
            <link>https://medium.com/@jonskulski/focus-8297a6643a34?source=rss-700ecd04dc6e------2</link>
            <guid isPermaLink="false">https://medium.com/p/8297a6643a34</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[focus]]></category>
            <dc:creator><![CDATA[jon skulski]]></dc:creator>
            <pubDate>Wed, 03 Jun 2015 19:17:49 GMT</pubDate>
            <atom:updated>2015-06-03T19:17:49.107Z</atom:updated>
            <content:encoded><![CDATA[<h4>Authors note:</h4><p><em>I found this in my drafts. I’m going to publish this unfinished, as is, because hey, I get an internet point and also there’s something silly about it.</em></p><p><em>Open on me, squawking about my fool-proof, follow-through process like I just got tablets from G-d. Smash cut to finding the posts months later, unfinished, in a drafts folder.</em></p><p>I’ve always found myself to get very far on projects when I’m on airplanes. There’s a few factors that play into it. Lots of coffee during travelling. It’s hard to move. No one wants to talk on airplanes. Little to no wi-fi. What do they have in common? They minimize distraction. They maximize focus.</p><p>Focus is hard. Staying on task is difficult. Right now, I’m fighting the urge to switch to facebook or check work email or a number of other easy ways to feel good or grab a false sense of productive.</p><p>I’ve been trying a new way of writing. When I have around 30 minutes before a meeting/scheduled event, I write a blog post. At the end of the 30 minutes I must either publish it or I throw it away.</p><p>I want to avoid putting the post in a giant pile of drafts. I think I might finish them some day, but I’ll never get to it. It just becomes a point of stress. I can trust that writing these words and working them through the ol’ nervous system has some sort of cumulative approach. That it some ways it makes me a better writer and thinker.</p><p>This post has been meandering like crazy. I’ve got 7 minutes left, and I’m gonna start cutting. Focus the post. Cut down on the distractions. Find the single thing I’d like to say and say it. It’s so hard.</p><p>I don’t like email. I don’t want it. There’s a time and place for it, I will admit. But it’s a terribly impersonal way to live. There’s been more than one time where I’ve gotten heated at an email because</p><p>I’m just terrible at this sort of thing. But what is it? Emailing word documents and updating JIRA tickets is often passed off as communication and organization. I reject that. It’s information chaff spit out to the ether. There’s not confirmation.</p><p>I’m so tempted to check my email as the first thing in the morning. It’s easy to open. It gives a small rush because ‘<em>hey! a person in the universe wants to communicate with me!’ </em>And it provides</p><h4>Authors note:</h4><p><em>I titled the post ‘Focus’ for god sakes.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8297a6643a34" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>