<?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 Christian Straubhaar-Jones on Medium]]></title>
        <description><![CDATA[Stories by Christian Straubhaar-Jones on Medium]]></description>
        <link>https://medium.com/@christian.straubhaar?source=rss-81b062f274cd------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*BInSS1YOc5kMpaxtEN3Phw.jpeg</url>
            <title>Stories by Christian Straubhaar-Jones on Medium</title>
            <link>https://medium.com/@christian.straubhaar?source=rss-81b062f274cd------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 12:15:09 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@christian.straubhaar/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[Getting new contributors up to speed on a large-scale React Boilerplate 3.x]]></title>
            <link>https://medium.com/@christian.straubhaar/getting-new-contributors-up-to-speed-on-a-large-scale-react-boilerplate-3-x-7358a2512e6a?source=rss-81b062f274cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/7358a2512e6a</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[redux]]></category>
            <category><![CDATA[react-boilerplate]]></category>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[redux-saga]]></category>
            <dc:creator><![CDATA[Christian Straubhaar-Jones]]></dc:creator>
            <pubDate>Thu, 05 Sep 2019 16:31:00 GMT</pubDate>
            <atom:updated>2019-09-06T12:33:39.312Z</atom:updated>
            <content:encoded><![CDATA[<h3>On-boarding new contributors on a Redux/Saga/Reselect project</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*0UclMxOauVlbNNK-0-jSGA.jpeg" /></figure><p>Getting the whole team ramped up to work effectively on a large-scale production React project can be difficult.</p><p>This guide is a step-by-step training process for getting new folks up to speed working effectively on a production-scale React application. It’s made for one specific team, but I’m releasing it into the wild for anyone whom it might help get a start on a big project like this.</p><p>It uses the <a href="https://github.com/react-boilerplate/react-boilerplate">React-Boilerplate</a> model (note that this is React Boilerplate 3.x, so uses a few different libraries than the most updated 4.x), with <a href="https://github.com/ReactTraining/react-router">React-Router</a>, <a href="https://redux.js.org/">Redux</a> for global state, <a href="https://redux-saga.js.org/">Redux Saga</a> for async, <a href="https://github.com/reactjs/reselect">Reselect</a> for memoization, <a href="https://github.com/styled-components/styled-components">Styled Components</a> for single-component styling, and <a href="http://facebook.github.io/jest/">Jest</a> and <a href="http://airbnb.io/enzyme/">Enzyme</a> for testing. <em>This paragraph is also your reminder to read at least the basics of the docs for those libraries and make at least a tiny MVP example for each before you jump right in to this combo tutorial.</em></p><p>This is a lot to take in at once, especially for someone who’s new to one or more of those libraries, and so this guide is here to help ease that process with a small training suite to practice making a single new component which requires async data, including a reducer, actions, selectors, a saga, styles, and tests. <em>Editorial and organizational asides are scattered throughout the article in italics.</em></p><blockquote>Note: this is a little out of date, and it’s definitely recommended to start with the newer 4.x React Boilerplate if you’re just starting out, but for those projects still in 3.x that need to on-board folks, hopefully this is still helpful.</blockquote><h3><strong>Get to it!</strong></h3><p>Let’s start basic. Using the React-Boilerplate (easy to download and install via Github), spin up a new component via the CLI. Go into the component folder and look around. Open up the index.js file. In the render method, add a simple new visual element, such as a Button, and style it with a styled component.</p><h4>Async</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/728/0*5eHJDN8gVDutXgIZ.jpg" /><figcaption>An old railway station clock.</figcaption></figure><p>Now time to add async actions with Redux Saga. Try a simple API call to an easy API (such as the very straightforward <a href="https://swapi.co/">Star Wars test API</a>), perhaps triggered by your shiny new button!</p><p>Create a constant and action in the respective constants.js and actions.js files, put a trigger for the action in your index.js, then add a yield takeEvery(YOUR_ACTION, handlerFunction) to the saga in saga.js to catch the action. Remember the handler function here needs to be a generator, with yield statements for every asynchronous piece of code. For a simple API call, you might be able to get away with only a yield fetch followed by some way to send the data back to your reducer / Redux store, such as a new yield put with a new action for delivering the returned data.</p><h4>Saving Data</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hm8yfK_X503XK_kq.png" /><figcaption>A nice old-fashioned floppy disk.</figcaption></figure><p>This in turn means another addition to the constants and actions files, as well as a new case in the reducer switch statement. Now save the data to your Redux store (in this case using Immutable.JS and returning a state.set). You probably won’t want to save every piece of data from every call to the Redux store in the future, but we’re learning about the full data life-cycle here, and so that’s an important part.</p><h4>Reading Data</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cZ5HhiNsaz8UAkwB.jpg" /><figcaption>DATA written out in scrabble tiles.</figcaption></figure><p>Let’s display our data, shall we? First add a selector in the selector file (technically not necessary in this setup if we’re accessing a bit of data saved on the component’s own Redux substate*, but remember that we’re covering all the pieces here). This takes 2 parts to be done correctly, a basic selector function and a “maker”, using createSelector(). This ensures that if there are multiple instances of the component, the selectors still memoize properly (see selectors section and links below).</p><p>*React Boilerplate automatically creates Redux substates for each generated component, namespaced to the component’s name. So when you need to read from another component’s Redux state, you’ll need to use a selector along the lines of state =&gt; state.get(&#39;myComponent&#39;).get(&#39;myPieceOfState&#39;) or state =&gt; state.getIn([&#39;myComponent&#39;, &#39;myPieceOfState&#39;]).</p><p>Back in the index file, let’s pop that selector into the mapStateToProps, then read the data off the props and display it somewhere near the button.</p><p>Voila! You have just created a full data cycle inside of your first React Boilerplate component! Pat yourself on the back.</p><h4>Tests</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zjO_KbrXYubGZZiG.JPG" /><figcaption>The TV test pattern from the 1950s.</figcaption></figure><p>Now to write a few basic tests: one for your button (or other UI piece), one for each action creator, one for your saga, one for your new reducer case, and one for your selector. The unit tests will be pretty basic for now, but even that is a good start!</p><p>And finally write one solid integration test that tests that when you start at your beginning (the click) you get all the way to the end (data displayed). This is always the most important test to write.</p><h3>More considerations:</h3><h3>Selectors</h3><p>Because you’re going to work on a big project where there will be multiple instances of components all wanting to use the same selectors, you’ll have to take some extra steps to make sure you make selectors that memoize properly. <em>I recommend re-reading </em><a href="https://github.com/reduxjs/reselect#sharing-selectors-with-props-across-multiple-component-instances"><em>this section of the docs</em></a><em> and reading </em><a href="https://medium.com/@parkerdan/react-reselect-and-redux-b34017f8194c"><em>this article</em></a><em> by Dan Parker, specifically the Advanced Usage section.</em> <em>If you’re using the React-Boilerplate github repo as a base, this should already be modeled in the pre-generated selector files such as </em><em>app/containers/App/selectors.js in </em><em>makeSelectLocation().</em></p><p>Make sure you implement at least one composed selector ‘maker’ that memoizes properly when used in multiple instances of the same component.</p><h3>Testing</h3><p>I strongly recommend you practice writing unit tests for every individual piece of the application, which at this point includes:</p><ol><li>Components</li><li>Actions</li><li>Reducers</li><li>Sagas</li><li>Selectors</li></ol><p>Many people have different theories on what good testing practices and coverage is. This tutorial requires only a basic coverage of one substantive unit test per code unit (a component, saga, selector, etc.) and one integration test per user flow. More tests are certainly good and often recommended below, but this is the bare minimum to learn how and get up to speed. <em>Make sure you are clear with whoever manages the project you’re getting up to speed on what the testing requirements are. Might as well start practicing writing all tests in the style preferred by your specific project.</em></p><h4>Testing Components</h4><p>As a reminder, there are different component rendering methods in Enzyme: <a href="https://airbnb.io/enzyme/docs/api/shallow.html">shallow</a> creates a simple, childless rendering of only a single component, perfect for testing simple components. This is useful for more presentational components, with few or no children to pass props to. <a href="https://airbnb.io/enzyme/docs/api/mount.html">mount creates a full rendering</a>, including children, perfect for testing the logic of a container component as it interacts with its child/children. Ideally, write full tests to test that each component renders fully and that each individual functionality works. <strong>At a minimum for the tutorial, write one practice logic test for the component</strong> (beyond a basic it(&#39;renders without crashing&#39;) test, which always a good baseline to start with, but doesn’t really test application logic).</p><p><em>To simplify testing Redux- and Saga-connected Containers, it is recommended that you abstract out the Redux provider initialization into a separate </em><em>Root component, such as the following (idea from </em><a href="https://www.udemy.com/share/1003MyAkQYeVxRQnQ=/"><em>Stephen Grider’s Udemy course</em></a><em>, recommended for those wanting a nice course on testing with Enzyme):</em></p><pre>({children, initialState={}})=&gt; {<br>  const store = createStore(<br>    reducers,<br>    initialState,<br>    applyMiddleware(sagaMiddleware)<br>  )<br>  return (<br>    &lt;Provider store={store}&gt;<br>      {children}<br>    &lt;/Provider&gt;<br>  )<br>}</pre><p><em>This component can be separately imported into all Container testing files and easily wrapped around testing containers, providing a test Redux store. If you are using the React-Boilerplate github repo as a base, this has been done for you in </em><em>app/configureStore.js , which you can import elsewhere and call as a function with 2 parameters, </em><strong><em>initialStore </em></strong><em>and </em><strong><em>browserHistory</em></strong><em>. See </em><em>app/tests/store.test.js line 12 for an example.</em></p><h4>Testing Action Creators</h4><p>Testing action creators should be simple and straightforward, only a test or two to check that constants match and payload data comes through as expected. Both can even be tested in one test. An example:</p><pre>describe(‘TestContainer actions’, () =&gt; {<br>  describe(‘creates Test Action as expected’, () =&gt; {<br>    it(‘has a type of TEST’, () =&gt; {<br>      const expected = {<br>        type: TEST,<br>      };<br>      expect(testAction()).toEqual(expected);<br>    });<br>  });<br>});</pre><p>If you start getting complex action creators, consider refactoring them by breaking them down to be simpler, smaller steps rather than starting to create lots of tests per action.</p><h4>Testing Reducers</h4><p>Unlike some other sections, the basic requirement here is a minimum of one test per case in your reducer switch statement, including the base case. Ideally, if one case handles multiple kinds of input (but does the same logic on each, otherwise write another case), write one test per type of input.</p><h4>Testing Sagas</h4><p>There are <a href="https://redux-saga.js.org/docs/advanced/Testing.html">two primary ways to test sagas</a>, either 1) testing the saga generator step by step (requires no mocking), or 2) running the full saga and asserting the result (requires mocking any APIs). If you have easy access to sample API data for mocks, number 2 might be easier. Either way, have tests that test each branch of your sagas, using cloneableGenerator() . For example, for each API you need at least a request failure and request success path test. If you request different resources from the same API, write a pair of tests for each type of call you make. Theoretically, you shouldn’t need much more than that for a simple API call, though double check yourself and, if in doubt, always write the test unless you’re positive it is useless.</p><h4>Testing Selectors</h4><p>Add a minimum of one test per complicated selector and one test per selector composed of other selectors, which probably easiest to do via the resultFunc() API on a composed selector. See the <a href="https://github.com/reduxjs/reselect#q-how-do-i-test-a-selector">Docs on selector testing</a> for more. <em>Feel free to require more on your project, but tests for simple selectors like </em><em>state=&gt;state.a seems like overkill.</em></p><h4>Integration Tests</h4><p>Finally, the most important tests of all! The integration tests. Write a minimum of one integration test per user flow. Since you’re only making a single simple component pair here, that will probably only mean one test. <strong>This one test is the most important of them all, though, and don’t forget that!</strong></p><h3>Common Issues</h3><p>As you begin working with this set up, especially coming from other systems and set-ups, you might notice some differences and difficulties. Here are a few common issues explained:</p><h4>Images</h4><p>Remember with images using React with Webpack you need to import the image file into your component and then add the imported file under the src attribute of the jsx &lt;img /&gt; .</p><h4>Incorporating CSS</h4><p>Often React projects recommend importing component-specific css into the component file itself, but this can in some cases cause code doubling and bundle bloat. I recommend importing central css into a common styles.js file. Or better yet, use nothing but styled components, top to bottom!</p><h3>Other Set-up</h3><p>In addition to the libraries, there are other set up issues that are important to work delicately on a large project like this.</p><h4>Set up your editor</h4><p>If using React-boilerplate, follow it’s instructions <a href="https://github.com/react-boilerplate/react-boilerplate/blob/55c3c6203476b20b3ca5d21e0266cbdba11b4285/docs/general/editor.md">here</a>. Otherwise, get the set up instructions from the admins and make sure your editor is set up to automatically enforce those rules.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7358a2512e6a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[To Bootstrap or Not To Bootstrap]]></title>
            <link>https://medium.com/@christian.straubhaar/to-bootstrap-or-not-to-bootstrap-c80368de4f39?source=rss-81b062f274cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/c80368de4f39</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[bootstrap]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Christian Straubhaar-Jones]]></dc:creator>
            <pubDate>Fri, 15 Feb 2019 14:49:13 GMT</pubDate>
            <atom:updated>2019-02-15T14:54:38.147Z</atom:updated>
            <content:encoded><![CDATA[<p>That is the question. Whether ‘tis nobler to get there quicker with some potential maintenance debt later or to suffer the slings and arrows of making it all from scratch up front?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/726/0*4kXGKJmz-FgD8d12.png" /><figcaption>Some well-worn boots, with ragged but functional bootstraps</figcaption></figure><p>Our particular use case is refactoring a large enterprise mapping application from Angular 2(-ish) to a React, Redux, etc., stack. The client wants most of the styling and such to remain the same, and the original used Bootstrap for a few styling pieces, though not that many. So we are left with a choice: to remake those styling issues from scratch on our own or using smaller third party libraries, or to pull back in Bootstrap and all it’s bulk?</p><p>Many developers don’t think twice about adding Bootstrap to a new project, and it can make things get to an MVP much more quickly. But for a long-term maintainability it can make things more complicated than it helps. As <a href="https://hackernoon.com/the-backendification-of-frontend-development-62f218a773d4">one recent article</a> put it: <em>“This makes </em><strong><em>easy tasks hard</em></strong><em> for the sake of making </em><strong><em>trivial tasks even easier</em></strong><em>.” </em>Bootstrap even mentions prototyping before production app uses on it’s landing page: “Quickly <strong>prototype </strong>your ideas or build your entire app with our … components”. To me this says they know their library is often not the best choice for production, but is intended primarily for prototyping and MVPs, times when you need to get something that looks good quickly, not for performant final enterprise applications.</p><p>It’s not that hard to get a good dropdown menu in place, though it might take a day or two. But debugging why some random Bootstrap CSS class is breaking your custom styles can take awhile, too, and by the fourth or fifth time you’ve done it you’ve more than lost all the time you saved by using Bootstrap in the first place. This is to say nothing of the bulk and bloat of all the extra JS and CSS you aren’t using. Bootstrap can end up being more of a burden than a benefit, in the long term. So here we debate some pros and cons of both sides.</p><h3>To Bootstrap</h3><p>If choosing to use Boostrap, there are a few options in a React project. The first and likely best is to use a conversion library like <a href="https://react-bootstrap.github.io/">React Bootstrap</a>, but each has it’s benefits and downfalls.</p><h4>React Bootstrap</h4><p>Some easy solutions to things that we don’t want to fight with in a conversion that will already take too long. Some bloat, but no jQuery.</p><p>Still technically in beta, which makes it a somewhat dangerous and dicey move. Might be a technical debt bomb down the road if it stops being supported or updated as changes are made to either Bootstrap or React, both ever-evolving libraries.</p><h4>Bootstrap Original (Steal only what we need)</h4><p>Not a real contender, since you have to bring in jQuery, which is notorious for fighting with React.</p><p>As such, certain zones where we use Bootstrap would have to be cordoned off from a lot of React DOM logic. Which creates a dangerous hybrid, which we’d have to copiously document but even still might be a huge liability.</p><p>We would get only what we need, no bloat. Still the liability makes this not a serious option. These are not just bugs, potentially, these are app-breaking massive failures.</p><h4>Bootstrap Original CSS Only</h4><p>If you only want the CSS from Bootstrap, you might have a slightly easier time of it, but even there, you have to ask if the bloat of ALL OF THAT CSS is worth the handful of classes you will want to use. Better to literally copy-paste the individual classes you need from the Bootstrap source code than add the bloat of a million classes that might conflict with other classes you want to use.</p><h3>Not to Bootstrap</h3><h4>To use a small library</h4><p>If we find lightweight simple libraries, they don’t add bloat, and add only what we want.</p><p>But those libraries may or may not be well supported, and being one-offs makes them less tried and true. They’re also more rigid, not having had to take into account all the different use cases that people might want, unlike something big and well-known like Bootstrap or React-Bootstrap. Bootstrap has done the conceptual work of finding types of components and classes people actually need and making them flexible enough for a vast array of use cases, and React-Bootstrap has done the technical work of making them viable in React.</p><h4>To make it yourself</h4><p>There is a lot of value in making exactly and only the thing you need for your use case, knowing each piece has a purpose. There’s also a lot of value in making the thing yourself so you know the ins and outs and can debug it effectively. But it costs a lot of time, and time is usually at a premium in software development.</p><h3>What I Chose</h3><p>I have the rare treat in this instance of my boss telling me that I can take the time I need to in order to do it right. And at first I tried pulling in a small third-party libraries for specific needs, but my first one (an accordion menu for our sidebar, where previously we used Bootstrap <em>collapse</em>) proved to be too rigid to match the previous version. I still will keep an eye out if I find just the right libraries for other use cases where we used Bootstrap, but for now I’m just going to build them myself.</p><h4>The main moral of the story is: before you add Bootstrap, ask yourself if you really need it. And don’t add it if you don’t.</h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c80368de4f39" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What it means to be an engineer]]></title>
            <link>https://medium.com/@christian.straubhaar/what-it-means-to-be-an-engineer-3c5a798034d0?source=rss-81b062f274cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/3c5a798034d0</guid>
            <category><![CDATA[diversity-and-inclusion]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[diversity-in-tech]]></category>
            <category><![CDATA[diversity]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Christian Straubhaar-Jones]]></dc:creator>
            <pubDate>Sun, 29 Oct 2017 22:05:49 GMT</pubDate>
            <atom:updated>2017-10-30T11:01:33.457Z</atom:updated>
            <content:encoded><![CDATA[<p>This is my engineering manifesto. On it’s most basic level, it boils down to this: solve real problems. Solve them on the ground, in the trenches, in everyday life where people need real, viable solutions the most, but they need solutions to their actual problems.</p><p>I first started drafting this post in the wake of the now-infamous James Damore Google memo. My favorite commentaries pointed out a problem in his reasoning that I think is a dangerous epidemic among software engineers. The problem was not just about how he misunderstood gender, which he did, but more fundamentally that he <a href="https://medium.com/@yonatanzunger/so-about-this-googlers-manifesto-1e3773ed1788">misunderstood the purpose of engineering (see point 2 of Zunger’s argument)</a>.</p><h3>Engineers Take on Big Problems:</h3><p>I chose to become an engineer to solve big problems. A few years ago I realized that my former path (academia) was not going to afford me the possibility to make things that would have real, wide-reaching impact the way I wanted, and I decided that was enough of a reason to quit — though there were other reasons, too.</p><p>Big problems are ones that people have been trying to solve for millennia, and which never have a true, simple, elegant solution. Problems like poverty, crime, or the big -isms — sexism, racism, classism, and so on. These things come from such complex and multi-faceted origins and have such an array of ways of showing and perpetuating themselves that any real solution has to have two big parts. In my mind, it has to be:</p><p>a) grounded in a big ideal (like truth, or justice, or equality)</p><p>and</p><p>b) molded to the exact specifics of that one scenario, those individual people, that specific culture.</p><p>If, for example, a solution isn’t idealistic enough, it usually lacks the human buy-in to be effective. On the other hand, lofty ideals get you nowhere if you don’t have good, specific plans for how to bring them about, and not just in general, but in the exact place you need.</p><h4>We Need the Right Data</h4><p>For both of those requirements, but especially for the second, we need the right data. And one of the places that the current tech industry and Silicon Valley especially so hugely fall down is that these big world problems need real-life, diverse input.</p><p>If you only ask one subset of the population what they need, you will build a solution that only fits that one group. And since rarely are modern tech companies even running the classic focus groups of yore, so often the question is never even fully asked; it’s left to the engineer to use their own skill and intuition to find an answer. But essentially what that means is <strong>you are only asking <em>one</em> person what they need</strong>. And usually, because it’s a software engineer, that person is a white, upper-middle class, Western man.</p><p>This causes huge issues down the line, as the product then gets used by people from all kinds of backgrounds all over the world. And suddenly a million use cases and a million needs that that engineer never foresaw take the product down unforeseen or dangerous paths. Who could have foreseen the day when foreign governments attempt to destabilize their rivals by posting fake news articles on social media, for example?</p><p>My brother worked in international development for several years, and he noticed a huge issue of divided priorities between the people on the ground and the board of trustees back in the US. The board would well-meaningly try to imagine their solutions to the problems they saw, but would often lack context to know what a viable solution would look like. They would prioritize what they saw as the biggest problem, and the people on the ground would take the help — something is better than nothing, after all — but the deeper problems would persist.</p><p>This is why we desperately need, at the very least, our engineers to have good advice from people who know how to ask the right people the right questions. Good UX researchers, for example, can prevent so much wasted effort. But on a fundamental level, we need the engineers themselves to be able to imagine life outside of themelves. Hence the recent push for empathy among engineers.</p><p>But beyond that,<strong> we need diverse engineers </strong>to solve problems in a way that works, and truly works, for everyone.</p><h3>Building a Bridge:</h3><p>To get down to the core of the discipline, let’s look at one of the oldest and most consistent needs we have had for engineers: building a bridge.</p><p>You don’t build a bridge because bridges are cool. You don’t build a bridge because it looks nice or because it’s fun. All of those things are and should be true: but as an engineer you build the bridge because people need to get across. That’s the only reason that really matters, and it’s what everything should come down to.</p><p>Sometimes software engineers, especially those known as having “passion” for tech, can lose sight of that. They get so deep in the weeds of the newest possible solutions and the coolest technology that they almost forget that they’re building a product to satisfy a real need. They might, for example, build a bridge that is structurally amazing, supporting tons of weight with a fraction of the normal amount of materials, but doesn’t have the width to allow the amount of traffic needed to pass over it.</p><p>Other times, engineers simply fail to ask what people need, and build bridges that are in the wrong spot, costing travelers hours of extra travel time every day, going out of their way. And often the engineers don’t realize their mistake, because the people are still using the bridge. A solution is better than no solution.</p><h4>Optimizing for users</h4><p>We are largely past the point where our primary concern is optimizing for hardware, or the kinds of math-oriented technical optimization that is traditionally associated with software engineering. Our devices have exploded with capability in recent years, and except for a few notable exceptions for people processing truly big data, we do not really need to optimize our algorithms if we want to optimize the success of our products.</p><p>We need to <strong>optimize our products for people’s real needs</strong>. And that means finding engineers who can ask the right questions, who can imagine a life outside their own. And especially it means building teams who have themselves lived diverse lives and can help each other develop that empathy.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3c5a798034d0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Women in Tech Demo Days Hackathon]]></title>
            <link>https://medium.com/@christian.straubhaar/women-in-tech-demo-days-hackathon-d6d654f885a2?source=rss-81b062f274cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/d6d654f885a2</guid>
            <category><![CDATA[diversity-and-inclusion]]></category>
            <category><![CDATA[how-to]]></category>
            <category><![CDATA[hackathons]]></category>
            <category><![CDATA[women-in-tech]]></category>
            <dc:creator><![CDATA[Christian Straubhaar-Jones]]></dc:creator>
            <pubDate>Thu, 03 Aug 2017 21:40:05 GMT</pubDate>
            <atom:updated>2017-08-18T13:39:19.664Z</atom:updated>
            <content:encoded><![CDATA[<p>Sometimes googling local hackathons leads to working with an awesome team with amazing women, having a great time over the weekend, and winning thousands of dollars in free training at General Assembly . . .</p><h3>Here’s how to do it:</h3><p>A playful guide to winning hackathons by a person who has been to exactly one. But my team won that one!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QKRaCnayQvWi_gCGi3JNVQ.jpeg" /><figcaption>Presenting our project to the judges and the crowd. All photos courtesy of Melissa Kelly photography, official event photographer (new photos added 8–18–17).</figcaption></figure><h4>IN THE BEGINNING:</h4><p>Convince a coworker or two to do a feminist hackathon with you. Come up with an idea, think it through a little, and bring it up with said coworker. If they like it, run with it! If not, bounce ideas off each other until you find something you can both get fired up about. You all have to be very on board so that you don’t burn out halfway.</p><p>As it gets closer and they establish an event Slack, find some more teammates and hash out the basic details of the project. Remember, even if it is your baby and it seems perfect, that every idea gets better with a lot of outside input. Try and bring in as diverse a team as possible, because the different perspectives you’ll get will be invaluable!</p><p>The first night, when you all meet, make a detailed plan of who does what and how, so you can really hit the ground running the day of. (Also, try to get more developers . . . which we were sadly not successful at.)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3ZR9gPTcD6yY_Lmp40onzg.jpeg" /><figcaption>Getting to know one another on the first night.</figcaption></figure><h4>THE CLIMB:</h4><p>Show up bright and early, sit down and get at it! You only have about 8 hours before you have to show it off, and you have to build all the basic parts in that time. There truly is no time to waste.</p><p>You’ll come in fresh from a good nights sleep (definitely recommended) and they’ll have amazing breakfast, which will definitely start the day right, so you can start with a good push! (Thanks Capitol One, for one of the best breakfast spreads I’ve seen outside of Scandinavian hotels.)</p><p>Clarify things that are still unclear about the project, but try not to spend too much time planning, because this is about the doing. The planning should have been done last night. And above all else, DO NOT PIVOT. To pivot mid-hackathon is to die the death of the half-assed flop.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pRfEqoyxX9_Exaa7OQrKZQ.jpeg" /><figcaption>A bright and early start.</figcaption></figure><h4>THE SLOG:</h4><p>But no matter how good the start and how hearty the breakfast, dark times will come. There will be hardships. There will be frustrations. The code will break and break again.</p><p>No matter how simple the MVP seems, and how tantalizing the stretch goals, you will never see them. The basic logic of the simplest version of the project is hard enough in 8 hours, stretch goals are only for those dedicated and admirable teams that decide to keep working on it after the hackathon (and probably don’t have jobs yet).</p><p>You will get tired. You will consume more caffeine than is recommended for most dairy cattle, much less human beings. As the hours go on, this will make you feel fuzzy, hazy, dark.</p><p>Don’t despair! Push on! The more viable and working your project is at presentation time, the liklier it is to meet with the judges’ approval.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fL96JTuAo5n4abFpG40c2A.jpeg" /><figcaption>The team, hard at work.</figcaption></figure><h4>THE RAMP DOWN:</h4><p>Practice your pitch at least once — though probably not the dozen times they’ll tell you to practice it. Make sure everyone on the team speaks (if they feel comfortable doing so) and has questions they feel like they could answer well.</p><p>Make a mad scramble for as much functionality as you can cram into the blasted thing before the official stop time, then, as the wise songs of our rising generations teach us, let it go.</p><p>Try to relax and breath for a minute. Don’t keep practicing the pitch right up until the final moment; take a true break. You’ve been pushing your brain to its limits for hours, and if you want it to work while you give the pitch, you’ll need to give it a moment’s respite.</p><p>Sit back. Relax. Enjoy. Chat with people! You’re almost done!</p><p>When the pitch comes, let it be the culmination of a full, fun day, talking about this cool thing you’ve built, rather an exercise in emitting the maximum number of words physically possible from your mouth in the allotted time.</p><p>After the pitch, you can sit back and enjoy the rest of the evening! You did it!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*isvHVUVmG_RokbOEgzWu5Q.jpeg" /><figcaption>Laughing after the pitch.</figcaption></figure><h3>The Surprise:</h3><h4><strong><em>Now shifting from general advice to my team’s specific circumstances:</em></strong></h4><p>We were absolutely not expecting to win. One of our teammates was tired enough that she just decided to head home and take a nap, since she figured we didn’t have any chance anyway. Every second or third presentation of the 13 different teams that pitched their projects I’d have a new favorite for who would win the grand prize. But all of them seemed way beyond our project.</p><p>So when they announced the honorable mentions, and our name wasn’t among them, I was sad, because I hoped we would have at least get an honorable mention. But as you can see in this video, when our team’s name was called as winners, we were shocked, and, as you can see about the 1:45 mark of this video, definitely freaked out a little.</p><p><a href="https://www.pscp.tv/w/1ZkKzOwYaLrGv">Tiffani @inaffit</a></p><p>Source: <a href="https://twitter.com/tiffani/status/888845982200352768">https://twitter.com/tiffani/status/888845982200352768</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uq7RBnhsrCPETuyqLoAbCQ.jpeg" /><figcaption>Stunned to have won.</figcaption></figure><h3>Our Project:</h3><p>If you want to see out project in all of it’s made-in-8-hours glory, look here: <a href="https://github.com/StraubJones/WIT2">https://github.com/StraubJones/WIT2</a></p><p>Everything original you see — artwork, design assets, and code — was all made in those 8 hours. Shout out to my awesome team for pulling it together so quickly!</p><p>One note (also in the Readme, which, as its title suggests, you should read) is that most of our original code can be found in: Modules -&gt; core -&gt; client. We used a generator for the boilerplate and, as they often do, it generated a lot more boilerplate than we needed for the basic app.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k9vQidKch1HMG2jzIhZAhg.jpeg" /><figcaption>The victorious team, plus judges (and minus Marisa, who figured we wouldn’t win and went home to take a nap).</figcaption></figure><h3>Conclusion:</h3><p>So if you’re wondering if you should check out hackathons near you, you totally should! Prestigious awards and thousands of dollars of awesome free training could be just a google search (and a harrowing but fun weekend of intensive work) away!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ABkSCEOIRiGiyETc1yUikQ.jpeg" /><figcaption>Go to a hackathon!</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d6d654f885a2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Volunteering with a Black Girls Code DC Workshop]]></title>
            <link>https://medium.com/@christian.straubhaar/volunteering-with-a-black-girls-code-dc-workshop-475f301583ee?source=rss-81b062f274cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/475f301583ee</guid>
            <category><![CDATA[volunteering]]></category>
            <category><![CDATA[education]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[scratch]]></category>
            <category><![CDATA[black-girl-magic]]></category>
            <dc:creator><![CDATA[Christian Straubhaar-Jones]]></dc:creator>
            <pubDate>Tue, 27 Jun 2017 15:38:08 GMT</pubDate>
            <atom:updated>2017-06-27T16:04:44.137Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*ruyOPDELiqUyWaj4lTj78w.jpeg" /><figcaption>Myself and another volunteer Malikia answering a question Brooklyn and Brook, who are both 11 years old, helping them to build a game of Pong using <a href="https://scratch.mit.edu/">Scratch</a>. Photo from this BGC <a href="https://twitter.com/volunteerBGCDC/status/878647278185185280">tweet</a>.</figcaption></figure><p>So when you actually look, it’s really not that hard to find awesome organizations doing amazing things for inclusivity and diversity in tech . . . and easy ways that you can help out!</p><p>I learned about Black Girls Code from another blogpost, <a href="https://code.likeagirl.io/volunteering-at-the-black-girls-code-robot-expo-87fadcf62154">here</a>, and I figured I should keep spreading the news. They’re an organization that hosts workshops and programs for young women of color to explore and learn the imminently important skill of computer coding, made affordable by generous gifts from donors and volunteers helping run events. This kind of work, making a real change in the world, is exactly why I changed careers into tech in the first place, and so when I heard about the awesome work Black Girls Code was doing, I knew I had to get involved. Especially with my combination of teaching background and tech, it felt like this opportunity to help out was almost made for me.</p><h4>They make it really easy to <a href="http://www.blackgirlscode.com/volunteer-signup.html">volunteer</a></h4><p>Funnily enough, when I <a href="http://blackgirlscode.ivolunteer.com/">looked</a> they had an event that needed volunteers coming up in just a few weeks. Signing up to volunteer couldn’t have been simpler, they had a website with the timeslots and types of volunteers they needed, you signed up and got a confirmation email right away. They even sent out auto-email reminders to help you remember it was coming up.</p><p>The training was super easy too. We had a video chat to discuss the general structure of the program, some guidance on the tech we were using, and that was it. Took all of 2 hours, then just showing up the day of to help out.</p><p>It helped that I have both tech and teaching experience, so I was able to jump in as an instructor just like that. But even for people who don’t have any teacher training, they provide enough curriculum that you could jump in fairly easily as a tech assistant. If you have no tech or teacher training, they always need non-technical volunteers.</p><p>It helps that their pedagogical model is exploratory and student-driven: the idea is more to give the girls the basic tools and let them discover what they can do on their own, with a little guidance. So most of the help we were giving was helping them articulate what they wanted the code to do, and then maybe giving a hint where they might find some of that logic in the interface. We weren’t there to teach, “first do X, then Y, then Z;” we were there to guide them in finding their own answers.</p><p>They also work in pairs, so they always have their partner to bounce ideas off of and explore before they need to ask an aide for help. Pair programming is fantastic for exploratory coding like this, getting the girls to articulate what they want to happen out loud and thus think through their logic more fully. It also makes it an exercise in teamwork and communicative problem-solving, which is a huge plus.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tiyTSHpxUoZOzL27l-iaeQ.jpeg" /><figcaption>Sitting down with one partnership as they talked through the logic of their code. Photo from this BGC <a href="https://twitter.com/volunteerBGCDC/status/878628851617853440">tweet</a>.</figcaption></figure><h4>They teach really cool tools: <a href="https://scratch.mit.edu/">Scratch</a></h4><p>What made that pedagogical model work is that we were using a really cool visual coding language called <a href="https://scratch.mit.edu/">Scratch</a>. Scratch was developed at MIT to help people who know nothing about coding start learning in a very intuitive, easy way. It’s all drag-and-drop, with literal blocks of code shaped like puzzle pieces that interlock in specific ways. That means that even very young kids can play around with it and produce amazing results, and unconsciously absorb a lot of core coding principles along the way.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/682/1*7MHaWHpsh6gU0k6Q7rcE1w.png" /><figcaption>A sample block of code, that makes the ball move around the screen and bounce off the edges, with a little bit of randomness in the amount of bounce.</figcaption></figure><p>Scratch takes the most semantic elements of programming languages (if / else statements, do / while loops, etc.) and vizualizes them so you can intuit the less semantic elements very clearly. For example, the forever loop above encloses the code inside it and has a little up arrow at the bottom, indicating that it will repeat. The conditional inside the “if” statement has a specific hexagonal shape and a question mark, to indicate it’s something that can be in question. Values are pill-shaped so that you can see that the same place that takes a hardcoded number (like the “10” in “move 10 steps”) also could take a randomized number or a variable. Kids can play around with it, try things out, and get some really interesting results.</p><p>After having used Scratch, if/when the kids transition to writing normal code, the basic concepts of loops, conditionals, event listeners, and more are already familiar. And drag-and-drop is incredibly intuitive as an interface for children. (Case in point, when I was 2 years old my dad brought home one of the first Apple computers with a GUI, and I proceeded drag and drop my favorite game into the startup system, so that every time the computer booted up it went straight into the Dungeon of Doom.)</p><p>As someone who used to find and evaluate digital pedagogical tools for my PhD, I really cannot praise Scratch enough as a tool for anybody wanting to get kids started learning programming logic, or even just general problem-solving and logical-reasoning skills.</p><h4>The girls were really awesome</h4><p>I won’t lie, it’s tiring to work with kids for a full day on the weekend, but it’s amazing to watch these girls are as they experiment and learn and discover how much they can do with a platform like Scratch.</p><p>We were giving them a nice breakdown of steps needed to make first a 1-player, then 2-player version of Pong, and eventually a self-driving virtual car, but several girls started off right away doing their own projects (with our encouragement, of course). Some were narrative, some decorative, some more . . . experimental.</p><p>Two of the girls I was working with stumbled on how to create a psychedelic background, for example:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*oF3ceU41w5AnL6hW3USpYQ.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/446/1*2UWor2F0_w1X1a-gc57OLQ.png" /><figcaption>A very simple script that just adjusts the background color effect over time, nonstop.</figcaption></figure><p>Every single pair came up with at least one unique element that differentiated their program from everyone else’s. Some used tennis rackets for Pong paddles, others human figures as paddles to make it seem like a basketball match, or others still created human players with a sensor area on the foot to make them kick the ball like in a soccer game.</p><p>And since all their projects were saved to their accounts on the Scratch cloud, they will be able to return to them anytime they wish later on and keep exploring coding on Scratch.</p><p>It was incredibly inspiring to see young girls able to jump into coding with very little training and no experience, and yet still produce fully-viable games in just a few hours! These girls are awesome, and I’m definitely excited to see the great things they’ll create in the coming years.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v75MGCXbGVN50EACxM2l7g.jpeg" /><figcaption>All the girls from the DC workshop. Photo from this BGC <a href="https://twitter.com/volunteerBGCDC/status/878660486006546432">tweet</a>.</figcaption></figure><h4>And if you want to see more inspiring photos of girls of color getting their tech on, see <a href="https://twitter.com/BlackGirlsCode">@BlackGirlsCode</a>, <a href="https://twitter.com/hashtag/BGC2017?src=hash">#BGC2017</a>, and <a href="https://twitter.com/hashtag/BGCDC2017?src=hash">#BGCDC2017</a> (for this specific event).</h4><p>Thanks to <a href="https://www.contactually.com/">Contactually</a> for the use of their space and to <a href="http://www.blackgirlscode.com/">Black Girls Code</a> for doing great work and letting me volunteer!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=475f301583ee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Survival: On Coding Bootcamp Teaching Styles (Hack Reactor vs. Iron Yard pt. 2)]]></title>
            <link>https://medium.com/@christian.straubhaar/survival-on-coding-bootcamp-teaching-styles-hack-reactor-vs-iron-yard-pt-2-a9af58b847de?source=rss-81b062f274cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/a9af58b847de</guid>
            <category><![CDATA[hack-reactor]]></category>
            <category><![CDATA[pedagogy]]></category>
            <category><![CDATA[the-iron-yard]]></category>
            <category><![CDATA[bootcamp]]></category>
            <category><![CDATA[coding]]></category>
            <dc:creator><![CDATA[Christian Straubhaar-Jones]]></dc:creator>
            <pubDate>Tue, 17 Jan 2017 21:26:39 GMT</pubDate>
            <atom:updated>2017-01-17T21:26:39.046Z</atom:updated>
            <content:encoded><![CDATA[<p>Many people don’t think to ask about a program’s teaching philosophy when applying, but it is the core that structures everything their program does, so ignore it at your own risk . . .</p><p>Pedagogy, or the study of learning, is something I’ve dedicated a large portion of time to researching, especially during my PhD in German. Although learning a foreign language is different than learning a programming language, many fundamentals remain the same. And the philosophies around learning that an educational program talks about with their students is often a hyper-simplified version of their actual full philosophy. So here’s a peek behind the curtain from someone who has seen two of the major current bootcamps from the inside, and knows pedagogy well enough to see the deeper philosophies they employ.</p><h3>Iron Yard: “Leave No Man Behind”</h3><p>The Iron Yard is structured very similar to many summer language intensive programs: 3 hours of hyper-focused instruction per day, with lots of extra work and an environment provided to allow students to go as far, or not, as they are willing to push themselves.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KVyYm509UPvSGx-x9jdtMg.png" /><figcaption><a href="https://en.wikipedia.org/wiki/File:In_this_undated_file_photo,_U.S._Army_Capt._Emil_Kapaun,_right,_a_chaplain_with_the_3rd_Battalion,_8th_Cavalry_Regiment,_1st_Cavalry_Division,_helps_a_Soldier_carry_an_exhausted_troop_off_the_battlefield_130311-A-CP123-001.jpg">A chaplain and a soldier carry a compatriot from the battlefield.</a></figcaption></figure><h4>Optimized for Logistics:</h4><p>It’s a model that has been proven to work, though it certainly is also optimized for program logistical concerns, and thus not always entirely optimized for maximum student learning. It’s easy to run a program with clear blocks of time, clear classes coming in and out, clear office hours, and so forth. The Iron Yard is very straightforwardly structured, and the routine is quickly established for new students. That means that less organizational overhead is required and less confusion ensues. This can be psychologically good for students who are going to be dealing with a lot of stress regardless, due to the intensive nature of the course.</p><p>But it also means that less is going on. They build in time for a few programmed larger discussions and group activities, but by and large the time is open for students to take advantage of or squander.</p><p>They also exercise firm boundaries. The organization works how it works and the staff all go home at 5. If you want to push beyond that and keep working hard, great, but you’re as good as on your own until the next day. The campus is always open, and your fellow students are there as resources, of course. That also means that the brighter students will spend a decent amount of project time helping the students who are struggling. Teaching is a great way to solidify knowledge.</p><h4>Optimized for a Baseline:</h4><p>They also optimize for making sure that every single student has a baseline knowledge of all the basics. This means that if enough students are struggling with a concept, they will take extra days on it. They will take class-time to build apps that were assigned as homework if less than half the class was able to complete them.</p><p>In this way it feels similar to a lot of team-building exercises, in which it is more important that we are all on the same page than that all of the work gets done. This pairs with the fact that Iron Yard has essentially no official gating mechanisms. There is no entrance examination of any kind, and at no point do they have tests to ensure understanding of programming fundamentals. They will let people go who cannot keep up with the output required, but there is no official assessment.</p><p>This means that almost everyone can use Iron Yard to get a baseline knowledge of front-end development basics. But it also means that mileage will vary widely in terms of how skilled graduates are. Being an “Iron Yard grad” might not be something that says a whole lot about your ability to future employers. It will be more on you, alone, to prove yourself on the job market afterwards.</p><h3>Hack Reactor: “Survival of the Fittest”</h3><p>Hack Reactor takes an opposite approach, in which there is always a lot going on. There is a lot of confusion and chaos, and a LOT of stress, but more material gets covered. And if you make it all the way through, you will have learned and built a ton. But many people don’t make it in, and fewer still make it all the way through the program.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*vDaaunqHe0XolCmj0tXTsg.png" /><figcaption><a href="https://commons.wikimedia.org/wiki/File:US_Navy_110528-N-JC271-110_Mass_Communication_Specialist_3rd_Class_Sebastian_McCormack,_assigned_to_Fleet_Combat_Camera_Group,_Pacific,_crawls_thro.jpg">A Navy soldier crawling through a ‘tough mudder’ challenge.</a></figcaption></figure><h4>Optimized for Exposure:</h4><p>There is a degree to which the pedagogical strategy of Hack Reactor can be summarized as, “Let’s throw everything at them, and see what sticks.” The sprint structure of the program means that you are constantly learning and building new programs using new tools and new methods, so that by the time you leave you can say you’ve got some basic experience with almost all of the frameworks and tools that are most popular in the job market.</p><p>This means you have basic experience with enough things to make tactical, informed choices about which tool to use to solve a given problem or build a given app. In the project-building phase of the program, you can choose to specialize in those frameworks you like or you can choose to use a variety in order to diversify your skills. You can focus on back-end, on front-end, or work across the stack. You can informedly experiment with learning new tools having a good idea how much of a time investment that learning will be.</p><p>So if you fall behind, they will not slow things down for you to help you catch up. There are chances to go over material that a student struggled with, such as office hours, but learning the material you didn’t get through is always up to you. And if you fall behind consistently, there is a chance that you will be dropped from the program. That chance adds significant tension and stress to the experience.</p><h4>Optimized for Struggle:</h4><p>Hack Reactor also cares deeply about their good name, and as such they are deeply invested in only graduating absolutely solid software engineers. They have extensive assessments and gating throughout the program, such that almost no student cohort finishes with all of its original members. If they feel you aren’t learning enough to well represent them after the program, they’ll let you go.</p><p>Ideally that tension helps nudge you out of your comfort zone into the “growth zone,” where you are truly pushing yourself and learning at your maximum potential. Beyond that growth zone, however, is the panic zone, in which your body is so stressed that it shuts down and you cease to function properly at all. Where the growth zone ends and the panic zone begins is different for every person. Hack Reactor offers a lot of support in one-on-one meetings and things like optional daily meditation practice, but there is still a good chance it will be too much.</p><h3>Mileage May Vary:</h3><p>Obviously, each person’s experience can be quite different depending on individual factors, the cohort they are a part of, and curricular changes over time. At Hack Reactor, the curriculum is constantly evolving, and at Iron Yard, it’s never sure how far in the curriculum a given cohort will get. I had an instructor tell me she had certain concepts she had been itching to teach but hadn’t been able to get any cohort far enough along to do them in the last year.</p><p>But hopefully this gives you enough of a sense of the pedagogical priorities of each to know what to look for, and how to choose what might be right for you.</p><h4>TLDR:</h4><p>The Iron Yard can be expected to be like an intense summer semester in college: long class hours and lots to do, but built to be doable for the vast majority of people. It aims to bring everyone to a general, knowledgable baseline. Hack Reactor, on the other hand, is a bootcamp in every sense of the word. 11-hour days, 6 days a week. Stress. Exhaustion. Pushing you to your limit. But for that, it covers more material and pushes you hard enough that, if you make it all the way through, you will know that you have absorbed as much as is humanly possible in a few short months.</p><p>As always, these notes are drawn from my personal experiences with both. Let me know what you think, or if your experience was different! This will likely be the final post in the Hack Reactor vs. Iron Yard series, so bring up questions you still have in the comments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a9af58b847de" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tech Stack Nitty Gritty: The Devil’s in the Details]]></title>
            <link>https://medium.com/@christian.straubhaar/tech-stack-nitty-gritty-the-devils-in-the-details-4075fbc90f75?source=rss-81b062f274cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/4075fbc90f75</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[project-management]]></category>
            <dc:creator><![CDATA[Christian Straubhaar-Jones]]></dc:creator>
            <pubDate>Thu, 10 Nov 2016 16:09:03 GMT</pubDate>
            <atom:updated>2016-11-10T16:09:03.139Z</atom:updated>
            <content:encoded><![CDATA[<p>This blog post is going to focus on the smaller details of choosing which technologies and services are right for developing a web application. It will go beyond the basic database/server/front-end framework (e.g. MEAN = MongoDB, Express.js, AngularJS, Node.js), into more specifics, such as which CSS preprocessor, which continuous integration service, and which compiler to use.</p><p>Each of these decision points has and will likely continue to be the subject of many, many good blog posts, <a href="http://lmgtfy.com/?q=less+vs.+sass">which I’ll trust you to find on your own</a>. This blog post is just a case study to help anyone starting a development project think through the logic of what will be better for their <strong>individual</strong> application, rather than falling into the trap of assuming one tool is always the right solution for a given problem. As the old adage goes, ‘If you only have a hammer, everything looks like a nail.’</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G_EBDI22mqYpKQTOnzpVfA.jpeg" /><figcaption>Sometimes a different tool is in order. Photo by<a href="https://www.flickr.com/photos/justinbaeder/5317820857"> Justin Baeder</a></figcaption></figure><p>First, a short description of our application:</p><ul><li>MVP (Minimum viable product): A live-synced shared whiteboard/text editor for use in interviews, remote collaboration, and remote teaching</li><li>(Major) Tech Stack: React/Redux, Express.js, Node.js, PostgreSQL</li><li>Stretch Goals: Audio/video teleconferencing integration (likely via WebRTC), GitHub issues integration, varied share modes and input customizations (pen color/size/shape, text syntax highlighting, etc.)</li><li>Timeline: 4 weeks — ideally 1 week researching/planning, 1 week building the MVP, 1 week creating stretch features, and 1 week of pure polishing</li><li>Team: 5 full-stack Javascript developers</li></ul><h4><strong>Step 1: Identify areas of agreement</strong></h4><p>We decided on our basic tech stack pretty quickly, though some discussion of the things to use in conjunction with React (Redux, Native, etc.) was in order. But once we began discussing the smaller details of how to set up and run the project, we realized that there were a lot of decisions we needed the think about.</p><p>We had a very strong team, but also a very opinionated one: each person had specific tools they knew best, or were most interested in, and between the lot of us it was quite a variety.</p><p>We went through the kinds of tools and conventions we wanted to use and identified which ones we were all already agreed on. These were:</p><ol><li><a href="http://redux.js.org/">Redux.js</a>: to manage complex, app-wide state</li><li><a href="http://www.material-ui.com/#/">Material-UI</a>: for easy front-end styling and design</li><li><a href="http://socket.io/">Socket.io</a> using namespaces: to handle live-syncing separate rooms, each with a whiteboard and a text-editor</li><li><a href="http://eslint.org/">ESLint</a>: following the AirBnB <a href="https://github.com/airbnb/javascript">Javascript</a>/<a href="https://github.com/airbnb/javascript/tree/master/react">React</a> style guide</li><li><a href="http://www.ecma-international.org/ecma-262/6.0/">ES2015/ES6</a>: transpiled by <a href="https://babeljs.io/">Babel</a></li></ol><h4>Step 2: Determine decision points</h4><p>From there we identified which types of tools we also wanted to use, but had some question as to which one would serve best:</p><ol><li>CSS preprocessor/extension language (<a href="http://sass-lang.com/">Sass</a> or <a href="http://lesscss.org/">LESS</a>)</li><li>Continuous integration service (<a href="https://circleci.com/">CircleCI</a>, <a href="https://travis-ci.org/">TravisCI</a>, or <a href="https://codeship.com/">Codeship</a>)</li><li>Compiler/Bundler (<a href="http://browserify.org/">Browserify</a> or <a href="https://webpack.github.io/">Webpack</a>)</li><li>Project Management (<a href="https://trello.com/">Trello</a>/<a href="https://waffle.io/">Waffle.io</a> or native Github Issues/Project boards)</li></ol><p>We had members of the group with preferences for each category, but we were aware that nobody in our group had used both tools in any of these categories, and we didn’t want to make decisions without considering both sides.</p><h4>Step 3: Research</h4><p>To not make any rash decisions, we chose to let everyone briefly look at both sides of each issue on their own.</p><p>So that we could get a little more depth, as well, we assigned each issue to one or to team members who would look more in depth at that particular set and report back what they found.</p><p>We broke for the evening and came back together the next day to discuss. We each looked at the sites for each tool to see their offerings as well as a variety of third party articles which compared and contrasted the tools in question. There are a million blog posts for each of these questions. Each one will offer slightly different points of view, but nobody ever has time to read them all. Generally, after reading a handful, you’ll find you understand the main points of difference. Then, knowing the major questions, you can easily skim another half dozen more relatively quickly and still understand with some nuance where they stand. At that point, you should be ready to discuss it.</p><p>(This approach is designed for smaller apps, where retooling as necessary is relatively easy. For larger enterprise applications, it might be worthwhile to have the assigned team member run limited trials with each different tool to get a more in-depth and personal sense for how they work, so that you can know for sure it will fit your purposes before investing significant development time using the wrong tool.)</p><h4>Step 4: Group Discussion</h4><p>The next day we came back together and reported our findings.</p><ul><li><strong>CSS preprocessor/extension language (</strong><a href="http://sass-lang.com/"><strong>Sass</strong></a><strong> or </strong><a href="http://lesscss.org/"><strong>LESS</strong></a><strong>)</strong></li></ul><p>We had learned that Sass was more of a full CSS extension language coupled with a pre-processor, whereas LESS was more of a bare-bones pre-processor. LESS behaved more like native CSS and didn’t require any work with the command line to set it up. This made it often ideal for people just starting out with a pre-processor or for designers who didn’t want to have to bother with language behavior (like running from top to bottom and reassigning variables as it goes) or installing it using the command line. But for a team of Javascript developers like us, the command line and language behavior were quite familiar and the easy extensibility of Sass with libraries/tool sets like <a href="http://compass-style.org/">Compass</a> or <a href="http://bourbon.io/">Bourbon</a> made it much easier to learn and more versatile to use.</p><blockquote><strong>The right tool for our app: <em>Sass</em></strong></blockquote><ul><li><strong>Continuous integration service (</strong><a href="https://circleci.com/"><strong>CircleCI</strong></a><strong>, </strong><a href="https://travis-ci.org/"><strong>TravisCI</strong></a><strong>, or </strong><a href="https://codeship.com/"><strong>Codeship</strong></a><strong>)</strong></li></ul><p>We found that CircleCI, TravisCI, and Codeship all had similar functionality: each ran regression tests on pull requests to ensure only viable code was merged. CircleCI boasted slightly faster test builds, but that was the only functional difference we could discern at first glance. The choice came down to which had the best support for our kind of project: namely an open-source, quickly- and intensively-developed application which would be built on a budget. While CircleCI had one free unlimited container, it was not well set up for open-source. And Codeship limited its free container to 100 builds per month, which we would likely exceed. TravisCI, on the other hand, provided full free support to all open source projects, making it the clear choice for us.</p><blockquote>The right tool for our app: TravisCI</blockquote><ul><li><strong>Compiler/Bundler (</strong><a href="http://browserify.org/"><strong>Browserify</strong></a><strong> or </strong><a href="https://webpack.github.io/"><strong>Webpack</strong></a><strong>)</strong></li></ul><p>Our preliminary research showed that while Webpack offered more functionality (full task management for testing, linting, minifying, etc.), the extensive set-up time would not be worth it for the MVP, for which we just need a simple bundler. But it <em>would</em> be good for when the app began to grow beyond the basic set-up. So we decided on an unconventional approach: to use both tools, each for different stages of development. We’d use a quick-and-dirty set up for Browserify until we got the basics done, then transition to using Webpack for later development, likely in Week 3, when we were (ideally) working on stretch goals.</p><blockquote>The right tool for our app: Browserify to start, Webpack for later</blockquote><ul><li><strong>Project Management (</strong><a href="https://trello.com/"><strong>Trello</strong></a><strong>/</strong><a href="https://waffle.io/"><strong>Waffle.io</strong></a><strong> or native Github Issues/Project boards)</strong></li></ul><p>We had some strong opinions in the group that ruled out solutions like Zenhub (because it changed the Github repo space too much), so we had the choice between going with an external project management system like Trello or staying within the Github frame and using their project boards. Both methods could theoretically be integrated with Github issues, though it is certainly easier with Github’s own project boards. Tools like Waffle.io are great for coordinating diverse teams, but since our team is all Javascript developers and we would be doing so much of our work in our Github repository anyway, we decided that it would be easier to just use their native project boards.</p><blockquote>The right tool for our app: Github issues/project boards</blockquote><h4>Step 5: Wrap up and revisiting</h4><p>Now that we had decided which tools to use, we discussed other organizations concerns, like if/when/how we wanted to do code reviews, who would take on which agile roles, and how we wanted to structure our sprints.</p><p>We also decided we would revisit which tools we were using and how we were using them periodically in our sprint retrospectives, to make sure that they were all working well. If we ended up finding a given tool was adding more blockers than it was helping, we needed to have the flexibility to switch.</p><h4>Conclusion:</h4><p>Hopefully this example helped you think through how to decide which tools to use. Maybe gave you some ideas of tools you might want to try out in your next application. As a developer, it is almost always a good idea to be trying new tools, but it can be overwhelming with so many tools out there! More and more emerge every day.</p><p>A little research and some group discussion go a long way, though, to helping you identify the new tools that will ease your process without adding excess workflow clutter. That way, you can always be learning and expanding your tool set as a developer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4075fbc90f75" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hack Reactor vs. The Iron Yard, Part 1: Autonomy and Pacing]]></title>
            <link>https://medium.com/@christian.straubhaar/hack-reactor-vs-the-iron-yard-part-1-autonomy-and-pacing-e3a5cdb4957?source=rss-81b062f274cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/e3a5cdb4957</guid>
            <category><![CDATA[codingbootcamp]]></category>
            <category><![CDATA[hack-reactor]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[the-iron-yard]]></category>
            <category><![CDATA[makersquare]]></category>
            <dc:creator><![CDATA[Christian Straubhaar-Jones]]></dc:creator>
            <pubDate>Tue, 11 Oct 2016 18:52:10 GMT</pubDate>
            <atom:updated>2017-04-05T23:54:39.389Z</atom:updated>
            <content:encoded><![CDATA[<p>Thus begins the epic series which will track my thoughts and experiences on the differences and similarities between the Front-End Engineering track at The Iron Yard versus the Makersquare/Hack Reactor bootcamp. My experience is with the Austin, Texas campuses of both, specifically, so I can’t speak to any regional differences that may exist, though I believe both programs attempt to keep their curricula more or less the same between campuses. My experience is also with these organization in 2016, and these are both programs that are constantly shifting and evolving, especially Makersquare/Hack Reactor, who are constantly updating/shifting their programs in small ways in the process of merging the two different curricula.</p><p>I am writing this series for two reasons:</p><ol><li>I would have greatly benefitted from this information when I was considering bootcamps the first time around.</li><li>Having done the first third or so of the The Iron Yard and (at present) the first half of Makersquare/Hack Reactor, I have the unique perspective of knowing both programs from the inside.</li></ol><p>A caveat: I did choose Makersquare over The Iron Yard and do feel it was a better fit for me personally, but that doesn’t mean I think it is the best fit for everyone. I definitely think there are many people for whom The Iron Yard is a better fit, and as such I will attempt to describe the benefits and drawbacks of both approaches.</p><p>This particular blog post focuses on the question of autonomy and pacing in both programs.</p><h3><strong>In General:</strong></h3><p>Bootcamps are intensive. Coding bootcamps are trying to prepare you for a career of continuous learning, often on your own, while still pushing you to be as active as humanly possible during the course of their program. As such, the balance between enforced structure and autonomy is a tricky and very important one. Finding the right program that has the right pace and right balance for you, individually, is key.</p><p>When you’re on the job, after the bootcamp, you’ll be learning primarily through whatever tutorials you can find online the the often tricky mess of official documentation. Any bootcamp worth it’s salt is deeply aware of this and tries to force you at every turn to struggle through that process of learning on your own, while still offering the resources and support you need to learn as much as possible in as short a time as possible.</p><p>Different programs will find that balance in a way that works better or worse for particular people. This can often be a hard thing to gauge before you’re actually in the thick of it, so I’m going to breakdown the approach to autonomy that each program takes, as I understand it. Anybody with a different experience, or anybody from the staff of either program who thinks I may have missed the mark, please comment! I’d love to hear alternative perspectives.</p><h3>The Iron Yard (TIY)</h3><p><strong>In short</strong>: The Iron Yard requires more specific autonomy on individual assignments through the first half, but less macro-level autonomy around the admissions process, navigating the bootcamp itself, and assessing your progress. In general there is a corporate atmosphere of wanting to check in more, not less, to make sure you’re ok. It also moves noticeably slower in terms of curriculum than Makersquare/Hack Reactor, which is more forgiving but also means less gets covered, in total.</p><p>When you’re checking out the Iron Yard, they’ll gently walk you through a lot of their expectations and answer a lot of questions before you need to ask them. You’ll talk to the campus head and your instructor before you start, and they’ll try to get a really good sense of whether their program will meet your needs. You’ll see the campus. They’ll invite you to their free crash courses, which I definitely recommend, since they’ll give you a fantastic preview into the instructor’s teaching style and the feel that the bootcamp has. All of this will give you a very good picture of what you’re getting.</p><p>That sense of what you’re getting extends to their good communication and frequent check-ins, one-on-one consultations, Friday huddles, and so forth. They give feedback on every assignment, and also have general progress one-on-one check-ins with the instructor every two weeks, so you know exactly where you are standing at all times.</p><p>Their entry requirements are also much less demanding, and if you’ve been doing much preparation online on your own, you’ll likely have most of them done by the time you are accepted into the program.</p><p>The only way in which they offer more autonomy is the structure of the assignments. All assignments that aren’t explicitly group assignments are solo, so you will be doing all the coding and all the work on your own. There are massive benefits and massive downsides to this model:</p><h4><strong>TIY Benefits</strong>:</h4><p>You write everything yourself, and it’s all public on Github, so your future employers can track your development and see lots of your work. It’s great for introverts, who work best on their own, and there’s support there for the first few hours when you need it. It also offers the closest parallel to most future work environments, where you’ll have to struggle through and learn on your own, but can ask for help occasionally if you need. Also, since you do everything yourself, you can take as much or as little time as you like, and that means it’s on you to challenge yourself and go above and beyond. It also means it’s more flexible in terms of scheduling, since you can leave anytime after noon most days to work anywhere you want, and are free to stop working once you’re done with the basic assignment.</p><p>(Personal take on time: I managed to treat Iron Yard rather like a 9–5 job, for better and worse, since I finished the assignment most days by 5. On the one hand, I felt like I could maintain a pretty active social schedule and still be a person outside of the bootcamp; on the other, it thus only became a bootcamp in the truest sense if I became my own drill instructor, which I found frustrating. To me, I felt like if I was paying literally thousands of dollars to learn intensively, I wanted the program itself to push me and require me to keep working, so that I didn’t have to manage both the emotional labor of pushing myself and the labor itself. Makersquare, since it requires you to be there literally 11 hours a day and continue improving/refactoring your code once you’ve passed the basic requirements, worked much better for me in this regard.)</p><h4><strong>TIY Downsides</strong>:</h4><p>Less material gets covered. Because you have to struggle through every step on your own, it goes slower. And because everyone is struggling through it on their own, if most of the class gets bogged down they’ll take an extra day or two on the same concept. As such, how far the class gets as a whole depends entirely on the cohort you’re in, and if you’re mismatched with the rest of the cohort it’s easy to get frustrated.</p><p>Also, it can get very lonely, unless you fight hard to not let it. It can be easy to not interact much with your cohort mates unless you push for it, and there’s something singularly depressing about spending 40+ hours a week surrounded by people you don’t feel like you’re really substantively interacting with or getting to know beyond the surface. This obviously depends on your cohort, and they try to push for socializing on Fridays to fight it, so this might not be your experience, but be aware it can get like this if you let it.</p><h3>Hack Reactor(HR)/Makersquare</h3><p><strong>In short</strong>: Hack Reactor demands significantly more macro-level autonomy from you, especially throughout the admissions process and assessing your progress in the program itself. It will be on you to think to ask and figure out what to ask, if you’re not sure. On the other hand, their pair programming model in the junior phase (first half of the program) means you’re never alone, but can also allow you to get passive and miss a lot if you’re not careful. In terms of pacing, they are more focused on making sure all the material gets covered than making sure everyone keeps up, so if even if the whole class cannot get through all the requirements of an assignment in time, they’ll still move on and still expect each of you individually to figure out the rest on your own. And it’ll definitely still be on the assessments (I’ll talk more about the Hack Reactor/Makersquare assessments in a later post).</p><p>In case you’re unfamiliar with the term, pair programming in their model means working on a problem in a team of two, with one person typing and the other person ‘navigating’, i.e. telling the person what to type. Both talk it through together when they get stuck.</p><p>This makes it much easier to bond with people from your cohort on a deeper level, because you are spending a lot of time with them. It also means if you end up working with someone who doesn’t match your personality, it can be a frustrating two days (each ‘sprint’ assignment spans two days). Both this and the physical environment of Hack Reactor/Makersquare (housed in the Capital Factory co-working space) can make it difficult on introverts or anyone who needs fewer distractions/more time on their own to figure things out. There are plenty of break times and solo-learning opportunities, to be sure, but the core of the work on assignments is still done together.</p><h4><strong>HR Benefits</strong>:</h4><p>You’ll be exposed to a lot more material, covering the full stack (front-end, i.e. the web pages people see, and back-end, i.e. the databases and servers that do all the work in the background). They cover not only what works, but to a much greater extent why it works that way, even covering a lot of computer science basics most bootcamps do not. You’ll always have someone there with you, so you never feel totally alone, even if it’s both of you struggling to understand the material together. You have to explain everything you’re doing OUT LOUD. I cannot overemphasize the benefits of needing to articulate every step to a person, because you understand code so much better when you can translate it into English. From what I understand, this training helps immensely during the job search, since white-boarding in interviews is essentially talking someone through your plan for how to code something.</p><h4><strong>HR Drawbacks</strong>:</h4><p>Hack Reactor/Makersquare enforces a truly grueling, exhausting pace, and it remains up to you to finish learning anything you personally didn’t get to in the program. The admissions process can be extremely frustrating, because they expect you to learn and do an <strong><em>immense</em></strong> amount entirely on your own at every step. That baseline of common knowledge that you establish through the admissions / pre-work process of working on your own is necessary, because it allows them to move much faster in the program itself. You will need to push yourself more than you probably believe humanly possible before the program starts, and then, once it starts, it will not really slow down (though it will be much easier to keep up with a group of others going through it with you).</p><p>The help you get will vary widely, both before and during the program, because most of it will come from their ‘fellows’, recent graduates of the program kept on as TAs. Most fellows are fantastic, but mileage does vary, and they are not teaching professionals. This is most noticeable during the pre-course, when you can’t necessarily expect them to check in on you or always respond to emails right away. Again, it will be very much on you to make sure you get the support you need. If you have the time and funds to do Makerprep in the preceding months and come in on Saturdays to work on pre-course material on the campus, I highly recommend both (I did neither, and the final week before the program started was the hardest thing I’ve done since my PhD exams).</p><h4><strong>In conclusion:</strong></h4><p>Both programs are going to be very difficult. A bootcamp is demanding, by definition. And the learning will, in the end, be on you, regardless of what program you enter. The Iron Yard, on the one hand, will take pains to make sure that you can handle everything given to you, and will leave a lot of the pacing/timing/scheduling up to you. If you are deeply independent and want your challenge to come more from within yourself, The Iron Yard might be the right pick. Hack Reactor/Makersquare, on the other hand, will enforce a stricter, harder pace, and will require you to keep it. There’s support there, but it will be on you to take advantage of it. If you want to be challenged from the outside, to have someone pushing you harder and harder like a true drill instructor, and you like working in teams, Hack Reactor/Makersquare might be the right pick for you. It’s the model that works best for me, to be sure.</p><p>Hopefully that gives you a better sense of how The Iron Yard and Hack Reactor/Makersquare look from the inside! Leave a comment if you have any questions, want to argue with anything I’ve said (I love a good debate, and I am also happy to update anything I’ve got wrong), or just want to say ‘Hi!’</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e3a5cdb4957" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MKS Week 2: Test-Driven Design (TDD)]]></title>
            <link>https://medium.com/@christian.straubhaar/mks-week-2-test-driven-design-tdd-445f7d9dcea1?source=rss-81b062f274cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/445f7d9dcea1</guid>
            <category><![CDATA[tdd]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[mocha]]></category>
            <dc:creator><![CDATA[Christian Straubhaar-Jones]]></dc:creator>
            <pubDate>Tue, 13 Sep 2016 19:52:38 GMT</pubDate>
            <atom:updated>2016-09-13T19:54:49.485Z</atom:updated>
            <content:encoded><![CDATA[<p>Dearest readers, I know you thought I had abandoned you, but this is not the case. For reasons I will outline in a forthcoming different blogpost or three, I am no longer in The Iron Yard’s Front-End bootcamp and am instead in Makersquare’s Javascript Full Stack bootcamp.</p><p>But enough about me! Let’s talk about code. Or, more specifically, let’s talk about what you can do before you actually write project code.</p><p>WHAT? Things before code? Say it isn’t so! Why would I care?</p><p>As an answer, let me present to you a common scenario:</p><p>Everyone who codes knows the feeling of starting a new project perhaps a little too excited, rushing headlong with no plan into a whole bunch of code. ‘I know exactly what I need,’ we might tell ourselves. ‘It’ll take maybe an hour.’</p><p>We also all know the feeling, many hours later, of staring at a bunch of code that mostly all works but is garbled, convoluted, and messy, while trying to write that one final piece without breaking everything else.</p><p>Ever start to feel like you’re working against yourself?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*Cdd13dhkI5NapGpwSU1_KA.png" /><figcaption>Tomasz Moczek’s <strong>Sisyphers</strong> in Wrocław, Poland.</figcaption></figure><p>It’s frustrating, it’s exhausting, and it doesn’t make good code. It can easily make a beautiful passion project into an exercise in futility, doomed to never be finished or realized to its full potential.</p><p>Isn’t there another way?</p><p>This is where test-driven design comes in. It does mean a little more up front, but it creates a simple and easy process to make sure your code never gets off track, and your project never bloats into a terrifying, unstoppable mess.</p><p>The idea is, before you write any project code, come up with a basic test of what you would want the first step of the project to do. (There are plenty of good testing libraries out there. I recommend <a href="https://mochajs.org/">Mocha</a>, with <a href="http://chaijs.com/">Chai</a> as an assertion library, because it reads so nicely, but there’s <a href="https://www.codementor.io/javascript/tutorial/javascript-testing-framework-comparison-jasmine-vs-mocha">several good ones</a>.) Don’t think too big here: think the smallest divisible chunk you can imagine. It can be as basic as:</p><ul><li>‘It should call for data from the server and deliver the specific piece of data I want.’</li><li>‘It should get input from the user and save that input in a variable.’</li><li>‘It should take an object and give me a modified object.’</li></ul><p>Try to limit it to one basic operation. If you get too complex at the start it’s easy to fall back into the mode of adding too many fiddly add-on widgets or getting lost in the line-by-line logic of the code.</p><p>Then, once you’ve written the test, write only the code that you need to make that operation work. No more code is allowed than what you need for that one test. It can be hard to stop yourself, once you’re in the code-flow, but you need to pull back as soon as you can make that single test pass.</p><p>Then, take a quick glance at your whole code and think: ‘Now that I’m looking at the bigger picture, are there some small tweaks I can make to make this better?’</p><p>Anything to make it simpler? More semantic? More legible? Clearer? Make it require less memory from the computer (think for a second about your big ‘O’ values, if it’s an app that might end up being a memory hog).</p><p>After you’ve done that (and made sure the fixes didn’t break anything), then you write another test. Rinse and repeat, ad nauseam.</p><p>Your basic workflow becomes:</p><ol><li><strong><em>Red</em></strong>: Write a test that is failing, because you haven’t written the code for it yet.</li><li><strong><em>Green</em></strong>: Write only the code you need to make that test pass.</li><li><strong><em>Refactor</em></strong>: Look at the code you just made and see if you can improve it. No extra functionality, though, just to make it do what it needs to pass the test in a clearer, better way.</li></ol><h3><strong>Takeaway</strong>:</h3><p>This system guarantees that you will always build an MVP (minimum viable product) before you get lost in the bells and whistles. This guarantees that everything you are doing is working. If something breaks, you already have a whole testing suite to see which parts are broken. It forces you to write clear, modular code that can be easily reused. The system of tests actually helps you to remember to pull your head out of the code and see the bigger picture. It’s (almost) all the things that you always say you want to do when you code, yet they’re so easy to forget.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=445f7d9dcea1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Week 4: Keep Your Eyes On the Structuring Principle (and/or Prize)…But Don’t Be Ahab]]></title>
            <link>https://medium.com/@christian.straubhaar/week-4-keep-your-eyes-on-the-structuring-principle-and-or-prize-but-dont-be-ahab-6eefa7b21ec9?source=rss-81b062f274cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/6eefa7b21ec9</guid>
            <category><![CDATA[time-management]]></category>
            <category><![CDATA[regression]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[priorities]]></category>
            <category><![CDATA[futility]]></category>
            <dc:creator><![CDATA[Christian Straubhaar-Jones]]></dc:creator>
            <pubDate>Sat, 09 Jul 2016 22:40:43 GMT</pubDate>
            <atom:updated>2016-07-09T22:40:43.368Z</atom:updated>
            <content:encoded><![CDATA[<p>I wrote some code that was messy and gross and convoluted last weekend. I could get all but one or two aspects to work, but those final elements were too elusive, and after 20+ hours (on one project, when we have 4 a week), I was done. I turned it in partial.</p><p>The problem was that I had kept getting more and more recursive, trying to nest functions within functions in a way that, for that particular section to work, would have had to literally nest infinitely. Turtles all the way down.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PrMRRmDfH07SNdUyHZVs4w.png" /><figcaption>Turtles from the local UT Austin turtle pond. Picture by <a href="https://www.flickr.com/photos/mybloodyself/">Dan Machold</a>, creative commons license.</figcaption></figure><p>The instructor looked at the code and said it was fine, that she would accept it as is if I would just send her a link to it live. But it bothered me. It wasn’t working <em>all the way</em>, so I figured I could make it work for real this time. My perfectionism began to get the best of me.</p><p>So I started over. This time I had a method that seemed like it would be much easier, at least conceptually. One big click handler that would work for every image, and a million if/else statements to discern. I ended up having to use ‘.contain()’ to check where they were. But it started to get away from me.</p><p>I worked and worked and got enmeshed in all the little problems and by the end I was creating another convoluted, inside out monster. It also wasn’t working. And I began to think seriously about starting over all over again . . . I was now already 40-ish hours in on something that should have maybe taken 20.</p><p>The problem, I discovered, was that with each problem I faced, I had allowed it to get a little more convoluted. I had focused only on what seemed like an easy way to fix this problem, and not kept in mind how the extra elements I was adding to fix this problem might affect the greater context. I had lost sight of the greater structuring principle while fiddling with minutiae.</p><p>And so I decided that, rather than spend another 10–20 hours finally getting it to work, I would leave this project unfinished. In addition to not having the extra time to dedicate to chasing this particular white whale during coding bootcamp, I knew that denying myself the satisfaction of finally finishing the cursed thing would make me remember this. In the long run it would better reinforce the lesson that I wanted to take away from the debacle: remember to not lose sight of the bigger picture in chasing the small details.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*eTd2dNMUlqknhB2FfHHtfw.png" /><figcaption>You win this time . . .</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6eefa7b21ec9" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>