Paul Hammant

That book is new to me. I wrote https://paulhammant.com/2013/05/07/android-and-the-art-of-war on Google vs MSFT and phones before the book. Mine's a perspective that doesn't mention Nokia or its leadership. I did own a Treo and loved it up to the OG iPhone - I repaired the eff out of it in the hope that something worthy would come along. I kidded myself I would write apps for it. I'd previously played with Simbian tech (and met a very bitter Simbian team dev in London one "eXtreme Tuesday Club" meetup in 2003). I had a Psion Organizer way back and Palm pilot. I thought Palm's WebOS stood a chance. I still own a Ubuntu Phone that I don't use - single script QML apps would have been the killer, but all that's passed now.

I've stumbled onto Envy earlier and I agree with you, there's not much out there about it except people talking about how much they love it[0]. I found this book[1] on Amazon in case you or anyone else is interested. [0]: https://paulhammant.com/2017/09/01/smalltalk-envy/ [1]: https://www.amazon.com/gp/product/0521666503

Git Flow is popular https://datasift.github.io/gitflow/IntroducingGitFlow.html Trunk-based is IMO the best http://paulhammant.com/2013/04/05/what-is-trunk-based-development/

Angular is making a run at replacing jQuery as we speak. It still lacks some of the easing and visual effects, but can do most of what jQuery is known for. http://paulhammant.com/2012/03/03/replacing-jquery-with-angular/ "Don’t even use jQuery. Don’t even include it. It will hold you back. And when you come to a problem that you think you know how to solve in jQuery already, before you reach for the $, try to think about how to do it within the confines the AngularJS. If you don’t know, ask! 19 times out of 20, the best way to do it doesn’t need jQuery and to try to solve it with jQuery results in more work for you."

> "Branch by Abstraction (instead of Branch by Source Control)" (http://paulhammant.com/) In the beginning, we avoided copying when we experimented by using flags; then we used source control branches to make diff "copies". In the end, we just copied.

I have been slowly (last 4 or so years) moving away from microservices towards the "cookie cutter" (http://paulhammant.com/2011/11/29/cookie-cutter-scaling/) model (we didn't use that term of art) and been very delighted with the change. I had completely drank the koolaid on microservices, but after having to maintain them in production for a few years, changed my tune. In my experience that "iterate and change the system easily and quickly" simply doesn't end up being true. That is the bait, but then comes the switch. Once you have a real system, heavily interdependent, the cost of changing things starts to go up greatly, and your ability to cleanly describe a working system becomes challenging. Answering simple management questions like "OK, so if we change X, what could break?"... "We should send out an email to all the teams to ask!" (ugh) The problem is that for most significant changes to a component -- there are changes to the interface to that component. So you have 'the choice' -- (1) Maintain this interface forever or (2) Ensure all the teams transition off it by X date, via a deprecation system. Both work, and most companies seem to use a mix of both, they strive for (1) until it gets insane, then they do (2) and force everyone to upgrade to X version by Y date.. rinse and repeat. We are currently doing the "fat binary" cookie cutter system. Our deploy is a single binary that does "all the things". There is a lot to like about this system. Easy to…

Here is the Lisp version Interface Builder. https://paulhammant.com/2013/03/28/interface-builders-alternative-lisp…

At least one early DI evangelist thinks so, https://paulhammant.com/2018/04/10/it-turns-out-we-didnt-need-dependen…

Ah, haven't heard of that, I was just a wee lad at the University computing center before I got out of high school. This what you're referring to? https://paulhammant.com/2017/09/01/smalltalk-envy/

And original Interface builder was developed in Lisp :) [1] [1] https://paulhammant.com/2013/03/28/interface-builders-alternative-lisp…

You want real continuous deployment? Or just continuous delivery? They are not the same thing. If you want real continuous deployment (which you should): - you need feature flags. See something like LaunchDarkly.com - you need Trunk Based Development. This means no branches. Or rather, only branches that live less than one business day. See https://trunkbaseddevelopment.com And https://paulhammant.com/categories.html#Trunk-Based_Development And https://www.branchbyabstraction.com/

You'll have to remember that all of those big companies have their tools and processes customized for their scale. Example: Instead of branching you would just create a `changelist` (a commit, a set of changes to files) and work on that. You can show it to your colleagues. You can build and test it. You can send the id to anyone to have a look at it, or test it themselves. You can have multiple changelists depending on each other, without being commited. This might be an interesting read for you: https://paulhammant.com/2014/01/08/googles-vs-facebooks-trunk-based-de…

further monorepo reading: Paul Hammant also likes to write about this and related subjects. https://paulhammant.com/categories.html#Monorepos

Reminded me of Paul Hammant's posts: - https://paulhammant.com/2012/04/24/call-to-arms-average-story-sizes-of… - https://paulhammant.com/2012/11/12/smaller-stories/

Paul Hammant? Thank you for your blogs and thanks for putting this site together, they're very informative. I work at a company that has been doing "Cascade" model for close to a decade [0], very similar to TBD but not quite the same. In addition to having a mainline trunk repo which everyone's work is pushed to, we have started utilizing Phabricator in the past few years -- it enables us to have short-running feature branches which aren't public to the upstream repository but can be shared if necessary and used for review (I'm not sure how similar this might be to GitHub flow? We use Mercurial). [0] http://paulhammant.com/2013/12/04/what_is_your_branching_model/

I think emphasizing Servo is the wrong goal. Ideally, when rewriting a large legacy app you want to take the StranglerApplication[1] approach. Netscape tried rewriting its software from scratch and we all know how that ended for Netscape[2] - Netscape is no more. Luckily, Firefox came from that whole mess. But I assume a lot of effort was lost, going from Netscape to Firefox. In idealized scenario, Servo slowly starts taking replacing parts of Firefox. First URL parser and media player, then slowly DOM, CSS, Renderer, and finally takes over and rewrites JS VM. The takeover is silent and gradual and user doesn't notices anything outside speed improvements. It's like some kind of silent Borg infection. [1] http://paulhammant.com/2013/07/14/legacy-application-strangulation-cas… [2] http://www.joelonsoftware.com/articles/fog0000000027.html

I don't buy the scaling argument in the slightest. You can scale a monolith more easily and more efficiently. It's called cookie cutter scaling: http://paulhammant.com/2011/11/29/cookie-cutter-scaling/ The one performance-related thing that microservices give you is isolation. Say you are a newspaper; you render articles and handle comments. If you have one article where the comments section completely blows up, then with a monolith, requests for comment handling will eat all the CPU and I/O, and articles will render slowly for everyone. If you have separate services for articles and comments, you should be able to ensure that articles continue to get enough resources to be served smoothly.

TIL: >The strangler pattern is a software architecture pattern where a legacy system or feature is strangled with new code. >Make something new that obsoletes a small percentage of something old. Put them live together. Rinse and repeat. Strangler Applications http://paulhammant.com/2013/07/14/legacy-application-strangulation-cas…

"[P]aired programming is about optimizing for the team" (source: http://goodrequirements.com/2013/pair-programming/). Long-lived feature branches optimize for the individual. A useful alternative is described at http://paulhammant.com/blog/branch_by_abstraction.html. What is your definition of "small"? The projects I worked on at ThoughtWorks for over three years numbered in the dozens of developers, all pairing, and all committing directly to master.

Or, say, Google and Facebook? http://paulhammant.com/2014/01/08/googles-vs-facebooks-trunk-based-dev…

> Also, note that Google is trunk based...with a single trunk across the whole company. I think Facebook is too? Yep! http://paulhammant.com/2013/04/05/what-is-trunk-based-development/

Paul links to it above in his comments: http://paulhammant.com/2013/12/04/what_is_your_branching_model/

:-) Although I kickstarted the project, I can't take a lot of credit for what it has become. It's a huge project now, with many people involved. Now, I'm just the crazy old uncle who can tell a good story about "the olden days". In the spirit of giving credit where credit is due, Paul Hammant is the one who came up with the HTTP proxy JS injection technique. Dan Fabulich, Nelson Sproul, and Patrick Lightbody rewrote it and refined it. (Some sources: http://paulhammant.com/blog/selenium.html/ http://docs.seleniumhq.org/about/history.jsp)

Perhaps http://paulhammant.com/2013/04/05/what-is-trunk-based-development/ ?

Why reinvent version control inside of WordPress? I'd rather version my content in git and build a static site from that. I think there's a real opportunity for github, or a github app, to revolutionize publishing by building on the existing content collaboration capabilities of git. I'm not the first to have this idea [1]; there are already people executing on it [2]. [1] http://paulhammant.com/blog/github-as-a-cms-to-end-cmses.html [2] http://prose.io/

Fun fact ... "VisualAge for Java was implemented in Smalltalk and the Team facility used ENVY/Developer under the hood" [1]. Of course eventually that product and team morphed into Eclipse. I was lucky enough to play as small part as a college-age intern working at an Object Technology International [2] Lab in Sydney. I soaked in the pair programming, watching the screen flash by. I read every book they gave me (e.g. The Toyota Way, this was before XP / Agile books existed). I was amazed they actually paid me to work on these problems. I was so proud to make contributions and still remember fondly the hand-drawn diagram of the architecture passed down like a relic through the team. I am still inspired by their passion and commitment to delivery. I definitely would not be the person I am today without the career defining experience working for Adrian Cho [3] and Dave Thomas [4] during that time. Periods like that are rare in a career - grab them if you can! 1 - https://paulhammant.com/2017/09/01/smalltalk-envy/ 2 - https://en.wikipedia.org/wiki/Object_Technology_International 3 - https://www.adriancho.com/ 4 - https://www.davethomas.net/

> Incremental rewrites You keep using this term and I don't think you know what it means. The Strangler pattern IS an incremental rewrite. You've suggested that it's possible to introduce incremental rewrites to old code and all I was clarifying is that by refactoring code written in an old framework (e.g. PHP 5.6) does nothing to eliminate technical debt (adds to it, in fact). The Strangler pattern is most often used when you want to switch languages (e.g. Java -> Rails) or when an older paradigm doesn't have a straight migration path (e.g. WebForms -> .NET MVC). The new code using the new framework essentially strangles the old code. For the record, I've advised over 100+ software companies, which I would say about 60%+/- of them are experiencing some type of major rewrite and of those, 9/10 are because they simply can't upgrade an outdated/unsupported/poorly architecture software framework. Trying to refactor an unsupported framework is simply not an option. You (1) either migrate it to the latest (if possible) and refactor over time, (2) strangle it with the new framework, or (3) rewrite it. That's it. Every other topic discussed is simply just one of those but semantically wrapped in some engineering jargon or nuance. This is all consistent with the examples here: https://paulhammant.com/2013/07/14/legacy-application-strangulation-ca… - C++ -> Java Spring - Powerbuilder/Sybase -> Swing - VB6 -> .NET - Java -> Rails - Java/Swing -> Rails The real world…

This looks very similar to Paul Hammant's "cookie cutter scaling" pattern (http://paulhammant.com/2011/11/29/cookie-cutter-scaling/), which I find equally baffling. Perhaps I've just never encountered the conditions which are favorable to it, but what I like about microservices is how they decouple every services' rate of change, and going back to lock-step deploys throws that all away. > In addition, with a monolith, the work of monitoring, alerting, configuration, and a local development is paid once. But with a microservice design, that cost must be paid for every service. The second sentence is only true if _every service_ actually rolls its own monitoring, alerting, etc. I cannot imagine a situation like that in practice. The standardization of those things (and more, such as build and deployment pipelines) is necessary to enable microservices in the first place. It's true that plenty of organizations committed to their microservice framework will also run some things outside of it, but I've never seen the ratio of things in the framework closer to 0 than 1.