Most interesting links of November

November 30, 2011

Recommended Readings

  • Recommended Reading by Poppendiecks - an excellent selection, starting with Lean from Trenches, Management 3.0, Specification by Example, The Lean Startup etc.
  • Eric Allman says that Programming Isn’t Fun Any More  because problem solving has been replaced with learning, configuring, and integrating tons of libraries, frameworks, and tools and many people agree with that (as discussion on reddit proves). In other words we tend to go for any benefit we can have without considering the costs and for "easy" solutions without considering the true enemy: complexity. Perhaps we should always listen to the Rich Hickey's Simple Made Easy talk before we add a lib/tool/framework?
  • Dean Wampler claims that functional programming can bring the joy back - "[..] a functional language, Scala, Clojure, Haskell, etc. will greatly reduce the amount of code you create. That won’t solve the problem of trying to integrate with too many libraries, but you’ll be less tempted. I also believe those libraries will be less bulky, etc."
  • Few quotes from a related article by M. Taylor: To put it another way, libraries make excellent servants, but terrible masters. | [..] frameworks [..] do keep their promise of making things very quick and easy … so long as you do things in exactly the way the framework author intended | On libraries: [..] we all assume (I know I do) that “plug in solutions X1 and X3″ is going to be trivial. But it never is — it’s a tedious exercise in impedance-matching, requiring lots of time spent grubbing around in poorly-written manuals [..] | On the effect of language choice: [..] different languages, with their different expressive power and especially their different culture, yield very different experiences.
  • To sum it up: Choose your tools and libraries wisely and always mind the global complexity. More usually means worse.
  • Java Magazine - Adam Bien: Stress Testing Java EE 6 Applications (page 41+) - do developer stress testing! Using: JMeter, VisualVM to find out resource consumption and behavior in the application, VisualVM's Sampler profiling tool [cca 20% overhead], a webapp to extract metrics from GF (STM)
  • Java Magazine - Polyglot Programming on the JVM (page 50; excerpt from The Well-Grounded Java Developer) - why you should consider polyglot programming and how to decide whether to use it and what languages to pick, f.ex.: "These [Java's] qualities make the language a great choice for implementing functionality in the stable layer [of the polyglot programming pyramid]. However, these same attributes become a burden in the middle and upper [lower, DSL, on the linked image] tiers of the pyramid; for example: Recompilation is laborious; Static typing can be inflexible and lead to long refactoring times; Deployment is a heavyweight process; Java's syntax is not a natural fit for producing DSLs." "There is a wide range of natural use cases for *alternative languages*. [after identifying such a UC] You *now need to evaluate* whether using an alternative language is appropriate."
  • Intrusion Detection for Web Apps - Detection Points - If security is a concern of your web application then you should build intrusion detection into the application f.ex. leveraging the  OWASP AppSensor project. The key is to detect malicious/unexpected behavior and proactively do something such as locking the user out or alerting the admins. The page linked above lists some common suspicious behaviors such as the use of multiple usernames, unexpected HTTP command/method, additional/duplicated data in request. Worth checking out!
  • Yammer Moving From Scala to Java- Scala is a cool language but sometimes its cost is higher than the benefits. Snippets from the post: "...the friction and complexity that
    comes with using Scala instead of Java isn't offset by enough productivity benefit or reduction of maintenance burden ...". "Scala, as a language, has some profoundly interesting ideas in it. [...] But it's also a very complex language. The number of concepts I had to explain to new members of our team for even the simplest usage of a collection was surprising: implicit parameters, builder typeclasses, 'operator overloading', return type inference, etc. etc." (It's claimed that only library authors need to know some of that but if it's a part of library APIs, the users need to understand it too.) Notice that the author isn't saying "Scala is bad" but only that Scala isn't the best balance of their needs at this time, as Alex Miller put it*. Important note: The text wasn't intended for publication and it is a private opinion of a Yammer developer, not the company itself. You should read the official Yammer's position where Coda puts it into the right context.

    • Refactoring

    • Opportunistic Refactoring by Martin Fowler - refactor on the go - how & why
    • Michael Feathers: Getting Empirical about Refactoring - gather information that helps us understand the impact of our refactoring decisions using data from a SCM, namely File Churn (frequency of changes, i.e. commits) vs. Complexity - files with both high really need refactoring. Summary: "If we refactor as we make changes to our code, we end up working in progressively better code. Sometimes, however, it's nice to take a high-level view of a code base so that we can discover where the dragons are. I've been finding that this churn-vs.-complexity view helps me find good refactoring candidates and also gives me a good snapshot view of the design, commit, and refactoring styles of a team."

    UIs and Web Frameworks

    • Devoxx 2011 - WWW: World Wide Wait? A Performance Comparison of Java Web Frameworks (slides) - the authors did extensive performance testing of some of the most popular web frameworks. Of course it's always hard to guess how general their results are, if/how they apply to one's particular situation, and if they aren't distorted in some way but it's worth for their approach alone (AWS with its CloudWatch monitoring, WebDriver, additional measurement of page load with HAR and a browser plugin). In their particular tests GWT scored best, followed by Spring MVC, with JSF and Wicket lagging far behind (especially the MyFaces implementation). Conclusion: A web framework may have strong impact on performance and scalability, if they are important for you then do test the performance early with as realistic code and load as possible.
    • JSF2 - Benchmark datatable by N. Labrot, 2/2011 - performance comparison of PrimeFaces 2.2.1, IceFaces 2.0, Richfaces 4.0.0M4 on a simple page with Ajax. I do not trust any benchmark that I don't fake myself :-) (for there are always too many factors that influence the conclusions to be drawn) but it's interesting anyway - and perhaps a good thing to do before you decide for a JSF component library.
    • Alex MacCaw: Asynchronous UIs - the future of web user interfaces and the Spine framework - users in 2011 shouldn't anymore wait for pages to load and operations to complete, we should build asynchronous UIs where changes to the UI are performed immediately while a request to the server is sent in the background, similarly to sending e-mail in GMail, which returns at once displaying a non-intrusive "Sending..." notification. As a user I very much agree with Alex.
    • Matt Raible's 20 criteria for evaluating web frameworks, 2010 (detailed description, here's a brief list) - Matt's results are disputable and as he himself says you should always do your own evaluation and spikes but the criteria are pretty useful: Developer Productivity, Developer Perception, Learning Curve, Project Health, Developer Availability, Job Trends, Templating, Components, Ajax, Plugins or Add-Ons, Scalability, Testing, i18n and l10n, Validation, Multi-language Support (Groovy / Scala), Quality of Documentation/Tutorials, Books Published, REST Support (client and server), Mobile / iPhone Support, Degree of Risk.

    NoSql

    • Don't use MongoDB via @nicolaiarocci - a (fake?!) bad experience with MongoDB - the text is not credible (the author is anonymous, s/he doesn't explicitely state which version of MongoDB they used, the 10gen CTO can't find a matching client and any evidence for some of the issues mentioned) but it  gives context for the read-worthy response from the 10gen CTO, and a post that nicely explains how to correctly design for MongoDB. A comment about MongoDB experience at Forsquare: "Currently we have dozens of MongoDB instances across several different data clusters storing over a TB of data and handling 10s of thousands of requests per second (mostly reads but the write load is reasonably high as well).Have we run into problems with MongoDB along the way? Yes, of course we have. It is a new technology and problems happen.Have they been problematic enough to seriously threaten our data? No they have not."
    • Martin Fowler on Polyglot Persistence - the are when will be choosing persistence solution with respect to our needs instead of mindlessly picking RDBMS is coming. Applications will combine multiple, specific solutions, f.ex. we could pick Redis (key-value) for caching, MongoDB (document DB) for product catalog, Neo4J (graph DB) for recommendations, RDBMS for financial data and reporting... (of course not all in one project!). Polyglot persistence will come at a cost (complexity, learning) - but it will come because the benefits are worth it - performance, data storage model and behavior more aligned with the business logic (NoSql databases ofer various models and tradeoffs and thus we can find a much better fit than with general-purpose RDBMs).

    Talks & Video

    • Adam Bien's JavaOne talk Java EE 6: The Cool Parts (1h) - absolutely worth the time - a very practical fly through the cool features of Java EE (eventing, ..), most of the time is spent actually coding. Don't forget to check also the interesting discussion below the video (JEE and other frameworks, Java FX and JSF 2, ...).
    • Jurgen Appelo's keynote How to Change the World at Smidig 2011 is well done and highly useful. We all strive to change the world around us - as consultants we want to make our clients more agile, as team members we want to make our Scrum teams more self-organizing, as employees we want to help building knowledge-sharing and open culture, ... . However it isn't easy to influence or change people and culture and if we aren't aware of all the dimensions of a change (system, individuals, interactions, environment) and how to work along each of them, we are much less likely to succeed. The knowledge and experience that Jurgen shares with us can help us a lot in having an impact. You can also download the slides and change management questions.
    • Project X: What is being a programmer like? (5min) If ever again a non-geek asks you what you as a developer are doing, just show him this short and extremely funny video (created by my ex-employer - perhaps they estimated how much time and energy developers loose trying to explain it to normal people and decided to prevent this great waste :-))
    • RSA Animate - Drive: The surprising truth about what motivates us (10 min) - entertaining and enlightening; once we've enough money to cover our needs, it's autonomy (self-direction), mastery, and purpose what motivates us (money actually decrease our performance). Now this is a great evidence for lean/agile - for they're based on making people self-directing and encourage mastery (as in continous integration and top quality to enable steady pace). Autonomy enables engagement as does a higher purpose ("make the world a better place") - Steve Jobs with his visions was able to provide such a purpose. Atlassian's FedEx Days are a good example of what engagement and benefits autonomy brings.
    • Simon Sinek: How great leaders inspire action (18 min, subtitles in 37 languages) - do you want to succeed, to change the world around you for the better, to start a new company? Then you must start by communicating "why" you do what you do, not "what" - like M. L. King, bro Wrights, and Apple. Very inspiring! (More in his Why book.)

    Links to Keep

    Favorite Quotes

    Refactoring is like advertising: it doesn't cost, it pays. - Mary & Tom Poppendiecks, Implementing Lean Software Development, p.166

    Clojure Corner


    Tags: scala architecture security clojure webdev java JavaScript library performance data

    Copyright © 2024 Jakub Holý
    Powered by Cryogen
    Theme by KingMob