<?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 Danny Fenstermaker on Medium]]></title>
        <description><![CDATA[Stories by Danny Fenstermaker on Medium]]></description>
        <link>https://medium.com/@lost_brogrammer?source=rss-5b0adcea7e11------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Vce0SLiCKr87prpKPT2emQ@2x.jpeg</url>
            <title>Stories by Danny Fenstermaker on Medium</title>
            <link>https://medium.com/@lost_brogrammer?source=rss-5b0adcea7e11------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 13:00:58 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@lost_brogrammer/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[Top Angular/Javascript Dev Tools]]></title>
            <link>https://medium.com/@lost_brogrammer/top-angular-javascript-dev-tools-102e9e9839de?source=rss-5b0adcea7e11------2</link>
            <guid isPermaLink="false">https://medium.com/p/102e9e9839de</guid>
            <category><![CDATA[es6]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[angularjs]]></category>
            <dc:creator><![CDATA[Danny Fenstermaker]]></dc:creator>
            <pubDate>Sun, 06 Mar 2016 21:52:25 GMT</pubDate>
            <atom:updated>2016-03-06T21:52:25.825Z</atom:updated>
            <content:encoded><![CDATA[<p>Having been working in Angular/Javascript for quite a while now, I have come across many tools for debugging and development. I thought I would do a quick write up of some of my favs and hopefully get some info about what everyone else is using.</p><ol><li>Batarang</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/725/1*cEbxgk6rPUNPzfFWn6qwKg.jpeg" /><figcaption>Batarang Chrome Extension</figcaption></figure><p>By far one of the most useful debugging tools out there. Batarang allows you to inspect the scope for an given DOM element. You can see scope state and your entire scope hierarchy. Some of the more advanced features even let you see things like Angular performance breakdown.</p><p>2. Webpack Dev Server</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XYZ8S0rCTD49r0N9S6MoVA.png" /><figcaption>Webpack Dev Server</figcaption></figure><p>The webpack dev server allows you to quickly and easily get a local server up and running. Paired with Webpack bundling system this server adds the ability for functionality like hot swapping and virtual file creation. The virtual file creation essentially means that your files are created in memory and served over a websocket. This makes it super fast to live reload code as nothing has to be written or read from file to do so.</p><p>3. Eslint</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*oRVo1FI63Uf4jgvgzLKFDA.png" /><figcaption>Eslint</figcaption></figure><p>Eslint has been a great tool for linting your code as you develop, a great way to keep things unwanted from making into production code. With eslint 2.0 I know they’re also making efforts towards parsing your code to figure out desired syntax style. Eslint is very configurable and a great addition to any build system/dev environment.</p><p>4. Babeljs</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*m8WU-S_2hUA_WswwLQ9hxA.png" /><figcaption>Babeljs</figcaption></figure><p>Quite simply Babeljs is a transpiler for ES6 and beyond. Babel does the heavy lifting when it comes to making your Javascript (enter version) backwards compatible for older browsers or forwards compatible for future features of javascript.</p><p>5. Lodash</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/885/1*Le6n-MXGxU4E14katEqh8Q.png" /><figcaption>Lodash</figcaption></figure><p>An incredible library of all of the things we normally write ourselves everyday in javascript. The Lodash library has implementations of native javascript functions which are often considerably faster than their native counterparts. This is a highly recommended addition to any dev environment.</p><p>6. Momentjs</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*2eSoJdTky3uSiWHHSl7irA.png" /><figcaption>Momentjs</figcaption></figure><p>If you’re dealing with dates and you’re not using this lib then you’re simply wasting a lot of your precious time and energy.</p><p>7. Rxjs</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/655/1*3mcoHLLuc5QS_pDzUKNqFQ.jpeg" /><figcaption>rxjs</figcaption></figure><p>If you’re are doing any kind of asynchronous development in javascript and you’re not familiar with Rxjs yet then you should get familiar quickly. Essentially Rx is a wrapper around any type of asynchronous event in javascript which provides a common api and extensibility. You can do things like combine any asynchronous event, create “observables” that are dependent on other observables and “observables” that are only allowed to run until another observables has finished.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=102e9e9839de" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Angular 1.x Architecture: Factories]]></title>
            <link>https://medium.com/@lost_brogrammer/angular-1-x-architecture-factories-b7dc62bc17bc?source=rss-5b0adcea7e11------2</link>
            <guid isPermaLink="false">https://medium.com/p/b7dc62bc17bc</guid>
            <category><![CDATA[es6]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[angularjs]]></category>
            <dc:creator><![CDATA[Danny Fenstermaker]]></dc:creator>
            <pubDate>Sat, 27 Feb 2016 19:47:55 GMT</pubDate>
            <atom:updated>2016-02-27T19:47:55.473Z</atom:updated>
            <content:encoded><![CDATA[<p>Recently I posted an article about <a href="https://medium.com/@lost_brogrammer/angular-1-x-architecture-decisions-4dc7b5c6abe1#.eb6rfek70">Angular Architecture</a> and the decisions we made at Jive Communications. I wanted to dive a bit deeper into the individual pieces and give an example of how each fits properly into the overall architecture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/420/1*OFYbg94wutwg5dLmwicQMw.png" /></figure><p>For us, factories represent the M in MVC. Factories are the state of a given entity. Let’s take a car for instance, there would be a car service that would know how to perform our CRUD operations. The car factory then would know how to take the data returned from the service and create its proper state for the front end. All changes made to the car would happen within its factory object and the car factory would know how to tell it’s corresponding service when to perform the necessary CRUD operation.</p><p>This gives us a few benefits:</p><ol><li>A bindable representation of the model</li><li>Separation of concerns</li><li>Uniform representation of a given entity throughout our app</li><li>Encapsulated state that can be passed around the app</li><li>Cancellation, should we need to cancel changes it’s as simple as nullifying the factory object</li></ol><p>One decision we made here was to keep the service exposed to the factory but not a property of the factory itself. We wanted to avoid access to the services through the factories. This was to eliminate tight coupling and hopefully avoid everything breaking when/if we changed the relationship with the service.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cc6adcf33b1e8cc77b1f378f4cccffa6/href">https://medium.com/media/cc6adcf33b1e8cc77b1f378f4cccffa6/href</a></iframe><p>Another decision we made was to have a static factory method on our factories themselves. This static method is responsible for abstracting away the angular’s involvement with this class. Essentially it is responsible for dealing with the necessary injectables and returning us a simple es6 class object. This affords us the following benefits:</p><ol><li>post angular creation we are dealing with “vanilla javascript”</li><li>We can export our class and test it without the need for mocking angular</li><li>All objects are new’d within this static function which isolates the creation behavior</li></ol><p>So as you may have noticed we inject our car service and immediately set it to a scoped variable within our enclosure. As mentioned before this was to avoid tightly coupling our services and prevent our app from becoming fragile. One thing to note here is that we are using webpack which automatically creates an enclosure around each of our classes. Also this enclosure variable method works with services because they are <a href="https://en.wikipedia.org/wiki/Singleton_pattern">singletons</a> and contain no state, you cannot for instance do this for angular’s scope or anything that is stateful.</p><p>Hopefully this helped and as always I would appreciate hearing about other people&#39;s awesome architecture decisions, ideas and thoughts. Thanks for reading!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b7dc62bc17bc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Angular 1.x Architecture Decisions]]></title>
            <link>https://medium.com/@lost_brogrammer/angular-1-x-architecture-decisions-4dc7b5c6abe1?source=rss-5b0adcea7e11------2</link>
            <guid isPermaLink="false">https://medium.com/p/4dc7b5c6abe1</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[angularjs]]></category>
            <dc:creator><![CDATA[Danny Fenstermaker]]></dc:creator>
            <pubDate>Sun, 21 Feb 2016 21:51:06 GMT</pubDate>
            <atom:updated>2016-02-21T21:51:06.818Z</atom:updated>
            <content:encoded><![CDATA[<p>Over the last year at Jive Communications we have made architecture decisions with respect to our front end have paid dividends. The first of which was to take the given entities that Angular has to offer and give concrete examples of how and when these should be used. We decided the following:</p><h4>Services:</h4><p>Services, given that they’re singletons, we use exclusively as api’s to the backend. They should contain only the logic necessary to make a request to the backend and return an observable or promise. This allows us to isolate our http logic and make the logic reusable throughout the application.</p><h4>Factories:</h4><p>Factories are used to hold state logic and are usually a layer to the services. In our case if we have a contact entity which has a users contact info then the factory would hold the actual data and the contact service would know how to grab that data from the backend. Each contact factory would have a reference to the contact service and know how to deal directly with that service.</p><p>This factory would be handed to directives and ultimately be bound to the UI. This gives us the ability to pass a factory around between directives or UI states until the user has completed editing the entity or cancels.</p><h4>Components/Directives:</h4><p>Directives in our case are to be as thin as possible. A directive should have, if necessary, a small amount of logic to deal with any custom DOM logic. Also a directive should keep its controller to a minimum, ideally the controller was passed a factory object that it then exposes to the template. If some custom logic needs to be added to help manipulate that factory then it should be isolated to the controller only.</p><h4>Filters:</h4><p>For filters we use these with extreme caution as they do run on every digest cycle and thus can be quite costly at times.</p><p>Just adopting the above requirements we have given our applications a level of consistency that has helped us debug our apps and work with other engineers quite easily. It aides with making future architecture decisions allowing us to focus on the details of the task at hand and not worrying about whether the architecture of this feature matches how the overall app is being written.</p><p>Thanks for reading, thoughts and other architecture decisions you have enjoyed would be great to hear.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4dc7b5c6abe1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Angular 1.X Error Reporting]]></title>
            <link>https://medium.com/@lost_brogrammer/angular-1-x-error-reporting-2351f5cdd6e7?source=rss-5b0adcea7e11------2</link>
            <guid isPermaLink="false">https://medium.com/p/2351f5cdd6e7</guid>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[angularjs]]></category>
            <dc:creator><![CDATA[Danny Fenstermaker]]></dc:creator>
            <pubDate>Tue, 16 Feb 2016 02:59:10 GMT</pubDate>
            <atom:updated>2016-02-16T03:01:01.039Z</atom:updated>
            <content:encoded><![CDATA[<p>Recently, at Jive Communications, we needed to find a way to gather error reporting across our applications. After looking at Raygun and Mixpanel, in addition to a few others, we ultimately decided on using just plain Google Analytics.</p><p>The main reason for this was it’s cost in addition to ease of use. We decided to build this as a reusable module for all of our apps to use thus unifying analytics across all apps.</p><p>After looking into Angular we discovered that they already had a hook for this to be done which made it quite simple. For Angular 1.x you simply create a factory named <strong>$exceptionHandler</strong> that returns a function taking the exception and cause as params.</p><p>After that its as simple as pushing the error to Google Analytics and then outputting it to the console per expected behavior. For us it was as simple as this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/22d5ffd19c10f1abed55a05d151f018a/href">https://medium.com/media/22d5ffd19c10f1abed55a05d151f018a/href</a></iframe><p>From there the analytics are pushed to Google where we can now see all errors that ever exist in our app. We included the url state at time of error, the browser this error happened in, and what the error was. We can now quickly identify issues that are happening cross browser and/or code that is breaking often.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2351f5cdd6e7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Angular, Webpack and ES6]]></title>
            <link>https://medium.com/@lost_brogrammer/angular-webpack-and-es6-4050134f9db0?source=rss-5b0adcea7e11------2</link>
            <guid isPermaLink="false">https://medium.com/p/4050134f9db0</guid>
            <dc:creator><![CDATA[Danny Fenstermaker]]></dc:creator>
            <pubDate>Thu, 29 Jan 2015 05:19:30 GMT</pubDate>
            <atom:updated>2015-01-29T05:19:30.738Z</atom:updated>
            <content:encoded><![CDATA[<h2>Angular, Webpack and ES6 Part I</h2><p>I am putting together the new tech stack for the company I am currently developing for <a href="https://www.spingo.com/">Spingo</a>. We are an Angular front-end team and feel that works best for our current needs. However, we feel the rest of our stack could use some spring(winter) cleaning and thus are embarking on the what, why and where that is a new stack.</p><p>So having tried React and ultimately deciding to stay with Angular, we were left deciding whether to leave Coffeescript and step into ES6. We decided ES6 was the better toolset to go with and left us in a better position for the future. At this point we would need to be able to have a build process that supported compiling of ES6, we also use Sass and wanted to keep with that, in addition we use lots of libraries that may or may not be CommonJS or AMD Modules so we would need to potentially support both module systems.</p><p>Our current build process is comprised of Angular, Require, Bower, Coffeescript, Grunt and a plethora of grunt plugins and custom tasks. Between all of this we are left with an overly complicated build process that while it gets the job done it was a little outdated and has room for improvement.</p><p>At this point it was time to decide on a task runner and module system. As far as tasks runners go the champions are <a href="http://gruntjs.com/">Grunt</a> and <a href="http://gulpjs.com/">Gulp</a> with <a href="https://github.com/broccolijs/broccoli">Broccoli</a> running way behind, but none the less an option. So Grunt, while well supported and widely used, we had been using it a while and seemed to slow down our build time as the project got bigger and bigger. This, combined with the fact that it’s process by which it runs tasks, didn&#39;t resonate with us as easily as Gulp did. This led to us going with Gulp and dropping Grunt for what is hopefully the faster and easier to grok lib.</p><p>So now the BIG question was what module system to use? RequireJS has been working “great” and if we were going to move away from that the replacement would need to do everything Require did. It would also need to allow us to push forward with some of the more forward thinking tech stack ideas we have been having. Again with the choices, now it was between Browserify, SystemJS, RequireJS and Webpack. Due to the need to pull in all module types we dropped Require and Browserify since they weren&#39;t built for that. SystemJS wasn&#39;t mature enough as a lib yet and so we were left with Webpack.</p><p>With all decision made it was time to jump in and hash out the new build! We have an Express backend for dev and in production we use Scala so first thing first was to get that Express server running. If your unfamiliar with this process there is a great article by Eric Elliot on <a href="http://ericleads.com/2013/05/getting-started-with-node-and-express/">Getting started with Node and Express</a>.</p><p>After that it was time to get started with Webpack and Gulp. Having worked with Gulp before outside of Webpack I was pleasantly surprised to see a npm module for <a href="https://github.com/shama/gulp-webpack">gulp-webpack</a> and how easy it was to get this started.</p><p>Reading up on Webpack I found that Webpack was all about the config file. So begin by creating a webpack.config.js in the root of your project. Here is an example of my config and comment containing the reason for each config property:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6444ab2324f9f9d28972614ad79b908e/href">https://medium.com/media/6444ab2324f9f9d28972614ad79b908e/href</a></iframe><p>With the above config file we are already well on our way to having a basic build process up and running. From here it’s getting Gulp started and if your not familiar with that process then here is a great article on <a href="http://markgoodyear.com/2014/01/getting-started-with-gulp/">Getting started with Gulp</a>. Assuming yourall setup with gulp and have a good understanding there I will show my gulp build and what is entailed, again complete with comments:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/17dc174b8aa5676b503cd77cae35ce0f/href">https://medium.com/media/17dc174b8aa5676b503cd77cae35ce0f/href</a></iframe><p>The following is a list of all npm modules necessary to run the build above: 6to5-loader angular css-loader exports-loader gulp gulp-livereload gulp-webpack sass-loader style-loader webpack</p><p>Given all of this and having the necessary modules installed this should give you enough to get started with a pretty advanced build process and an awesome tech stack. I will continue this series as I build out this new build process and refining things like auto reload, concat the bundles, updating the build version and of course building for production. Hope this helps and any questions, comments or ideas on how to make this even better please share.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4050134f9db0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The power of Naming Conventions]]></title>
            <link>https://medium.com/@lost_brogrammer/the-power-of-naming-conventions-4e5d9df14d27?source=rss-5b0adcea7e11------2</link>
            <guid isPermaLink="false">https://medium.com/p/4e5d9df14d27</guid>
            <dc:creator><![CDATA[Danny Fenstermaker]]></dc:creator>
            <pubDate>Sun, 16 Nov 2014 22:13:03 GMT</pubDate>
            <atom:updated>2014-11-16T22:13:03.548Z</atom:updated>
            <content:encoded><![CDATA[<p>As developers we are constantly being challenged with learning new libraries and frameworks, these challenges along with the projects we work on are what ultimately shape our skills and abilities.</p><p>Personally I have found the challenges both rewarding and capable of making me wish I could punch baby seals. One of the biggest frustrations when working with someone else’s code is the ability to quickly grok what they are trying to accomplish and jump into or branch off of their functionality.</p><p>I wish I could say that I am not guilty of the above but after doing some soul searching and with the help of my team, I have realized that this is an area that I can use some work. So then my goal here is to take my thoughts in addition to some research I have done online and make an argument for being extremely critical when it comes to naming conventions.</p><p>The first article I read was in a blog post by <a href="http://chrismdp.com/2012/09/the-power-of-good-naming/">Chris Parsons</a> in which he stated:</p><blockquote>Naming things is hard. Why do we expend so much effort to get them right? Because naming programming concepts well gives us a big insight into how they fit into the system we’re designing. Continually renaming things records our insights as we go: the right names for our objects, methods and variables will yield fresh insight and in turn shape the design of the system.</blockquote><p>This to me defines the necessity for naming conventions and if taken as a hard and fast rule I feel it could clean up the inability to grok someone else’s work and quickly get up to speed. Naming all objects properly and with intent gives someone else a blueprint to your project, this is especially true with file names. If your file structure is properly defined and named one could follow a path of “parts” and find the functionality they’re looking for without even needing to step through code.</p><p>The biggest offense I make is with variable and property names. I often find myself trying to name a field or variable something very short and quick. This works for the now but in a few weeks or days when I come back to look I find myself cursing old me. For the sake of progress I generally keep moving forward and committing the ultimate sin which is not cleaning it up and improving my skills. That being said I am working on it and getting better and after all I mean as Martin Fowler says:</p><blockquote><em>There are two hard problems in computer science: Cache invalidation,</em><strong><em> naming things</em></strong><em>, and off by one errors.</em></blockquote><p>So properly named variables can mean the difference between following a blueprint through our code or spending time putting breakpoints in and identifying the functionality via application and variable states. The most important reason I see for good naming is stating intent and clearly defining what the end result of the functionality should be. To drive my point I have created this Gist that shows the difference between good and bad naming:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bacf4f74477490c9ce18d45110d648e5/href">https://medium.com/media/bacf4f74477490c9ce18d45110d648e5/href</a></iframe><p>The top file BadConventions.js has by all means the proper functionality and structure. With such little code you can both grok this very quickly and for the most part infer the intent. The code is very short though and this type of naming in large applications would quickly lead to some loss in our ability to know the intent of our systems inner-workings.</p><p>The bottom file GoodConventions.js from the start displays intent. We quickly learn that we are dealing with a list and that the two functions are intended to act upon the list. With more knowledge into our system as well as the applications purpose we could derive much more meaningful naming conventions. The end result is a systematic and fluid flow through our code ultimately leading one from the beginning of your app out to the different endpoints without needing to punch baby seals.</p><p>Thanks for reading and I look forward to any comments or feedback.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4e5d9df14d27" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Angular Directive Communication using promises]]></title>
            <link>https://medium.com/@lost_brogrammer/angular-directive-communication-using-promises-9ff63eaaef07?source=rss-5b0adcea7e11------2</link>
            <guid isPermaLink="false">https://medium.com/p/9ff63eaaef07</guid>
            <dc:creator><![CDATA[Danny Fenstermaker]]></dc:creator>
            <pubDate>Sat, 13 Sep 2014 03:33:51 GMT</pubDate>
            <atom:updated>2014-09-13T03:33:51.186Z</atom:updated>
            <content:encoded><![CDATA[<p>Being fairly new to Angular and thus learning the in’s and out’s of the framework I recently came across the need for cross Directive communication. My first shot at this was using the app.$emit and I felt like this was not isolating the functionality of communication enough. With that I was looking at other options and decided to use something along the lines of the mediator pattern.</p><p>Angular being what it is I looked around and decided to use a mediator directive and matcher or child directives that register with the mediator assuming it’s in scope.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ph5EHY6Z_YOqp6wLhxbGUA.png" /></figure><p>These child directives register with the mediator and are returned a promise. In our use case we needed to see if another child/matcher directive had the same properties. Assuming a match is found the two directives have access to the same resolved promise and get the info they need. While our use case is simple any comparison or resolution case can be fulfilled.</p><p>This seemed cleaner to me simply because it isolates the functionality of a given element and allows the element to never have to know it was registering with the mediator.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8iinZ1mJoD9bba4pb_4uxg.png" /></figure><p>I know there is room for cleanup here and that this is abusing the idea of promises but the cleanliness of the end result was the lesser of the evils. That being said I would enjoy hearing peoples opinions and how this may have been better handled. Thanks for reading!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9ff63eaaef07" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>