8th Light Blog

8th Light | Chicago, LA, New York, Austin, London, REMOTE | https://8thlight.com/ We are a global team of software, design, and technology professionals. We help clients imagine and create elegant, robust, and groundbreaking digital solutions to complex problems. https://8thlight.com/careers Looking for VP of people, senior accountant, technical director, senior ux designer, and of course senior and principal level developers.

btw the agile manifesto (and similars) has such "we value X over Y" phrases. Another thing; as this one says, the values are the rules (well, should be). Breaking (intentionaly) them is a compromise needed sometimes. While not following, is different matter.. https://8thlight.com/blog/stephen-prater/2020/09/15/values-rules-break…

Check out https://8thlight.com They have offices in Austin TX, Chicago IL, London UK, Los Angeles, Madison WI & New York They have one of the few blogs that still has a place in my daily RSS feeds https://8thlight.com/blog/ I considered joining them for the same reasons as you a few years back after speaking with some employees here in London, but another opportunity came up. I sort of regret it now.

Worth reading "The Hypermedia Maturity Model" afterwards https://8thlight.com/blog/jason-desrosiers/2018/05/30/the-hypermedia-m…

I'd second this comment. I found lack of movement to be the problem for me. After several hours in front of the computer coding, browsing, whatever, I'd find myself feeling zombie-like and brain-fogged. I got inspired by the Walk and Code blog post[1] and bought a walking treadmill for work. Bye-bye zombie feeling. I work in an open office environment, so I needed one that was quiet. I bought the Rebel Treadmill 1000 and it's so quiet me and my office mates can hardly hear it over the sound of the HVAC system. Not affiliated with the company that makes them, but I heartily recommend their treadmill if you get in the market for one. [1] https://8thlight.com/blog/doug-bradbury/2010/02/25/walk-and-code.html

It's been a while since I tried to get into Clojure/Cljs but when I did I remember errors like the one in this article being cryptic: https://8thlight.com/blog/connor-mendenhall/2014/09/12/clojure-stacktr… > Caused by: java.lang.IllegalArgumentException: Don't know how to create ISeq from: clojure.lang.Keyword What's an ISeq? I can guess that' it's part of clojure's implementation from java.lang.IllegalArgumentException, but that's what I'm talking about when saying that clojure isn't a great first language because of how you have to both understand a little bit about clojure and a little bit about java, when it comes to errors and namespaces.

I'm one of those who think the JVM is a big plus instead of a big minus. For example, here is a post how you can easily deep dive into the internals of the JVM to figure out a problem: https://8thlight.com/blog/colin-jones/2017/03/17/everybody-ooms.html I wanna see this kind of tooling for other languages. The JVM gives you amazing tools that are already there for you even if you're not an expert.

1. To understand Clojure stacktraces you should read https://8thlight.com/blog/connor-mendenhall/2014/09/12/clojure-stacktr… Although I agree the lengthy huge Java dump when crashing is pretty awful, you can ignore most of it. 3. I would recommend you look into Parinfer - https://shaunlebron.github.io/parinfer/. You can manage scopes with levels of indentation, rather than having to move parens around. It works with most major editors, including Emacs.

> Just one point, please make sure you have designed DB access as a core part of your framework (e.g. [1]). Too many frameworks discount database interaction until it's too late. I strongly advise against this. One of the reasons Flask is so attractive is the fact that it does not enforce any database on you. Thanks to its decoupled design you can use it purely as a routing library, which is great! Letting the framework decide something important as the database is a bad idea. [1] [1] https://blog.8thlight.com/uncle-bob/2012/08/13/the-clean-architecture.…

Uncle Bob recommends in "Make the Magic go away" that programmers do some programming in assembler to help demystify languages and language features that seem foreign. I know it has helped me. https://blog.8thlight.com/uncle-bob/2015/08/06/let-the-magic-die.html

Check out the guys over at 8th light: http://blog.8thlight.com/ Uncle Bob in particular (the author of Clean Code[0], The Clean Coder[1], and the Clean Coders videos[2]) is a lot like Wozniak. [0] http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/01… [1] http://www.amazon.com/Clean-Coder-Conduct-Professional-Programmers/dp/… [2] http://cleancoders.com/

Bob Martin wrote about a variant on this point a while ago: > I'm sorry for your impending failures. I'm sorry that you're going slow and just don't know it yet. And I'm very sorry that when you finally brute-force your way to some modicum of success that you will credit your bad behavior, and recommend it to others. God help us all, because you won't. http://blog.8thlight.com/uncle-bob/2013/03/05/TheStartUpTrap.html

Robert C. Martin (known as "Uncle Bob" to many) wrote a blog post somewhat related to this recently. The gist is that Extreme Programming the name is dead because Extreme Programming the principles have been (mostly) widely adopted. It's a great read and I recommend checking it out. http://blog.8thlight.com/uncle-bob/2013/12/10/Thankyou-Kent.html

Hear..Hear...Maybe HN should do a list of US companies that indulge in illegal stuff like unpaid internships. For starters, http://www.8thlight.com/apprenticeship is one such company where a friend interns for free -- The Ruby switch (from Php) was so great that she is doing an unpaid internship there.

> I've yet to meet an anti-TDD zealot who has actually spent a month developing the art of TDD. The detractors tend to be people who write really brittle tests that are a pain to maintain. OK, sure. I'm basically pro-TDD, seeing as how everyone's taking sides. Yet there's a problem here, which is that (as Martin says here) bad testing is basically a design problem. To write better tests, learn better software design - which is to say, you do not do it (or at least most efficiently) by doing more TDD. This stuff is not in the brochure. And it should be; because without it, the claims made by TDD evangelists are somewhat misleading. No, it will not make you a better engineer on its own, at all. No, it is not a substitute for getting your whiteboard marker out and drawing a few boxes, or thorough code reviews, or whatever else. Sandi Metz makes this point in Practical Object Oriented Design in Ruby[0]; and the chapter on testing is right at the end of that book, presumably for the same reasons (get the design sense first, then you'll get a sane red-green-refactor thing going). Note that I'm not talking about Ian Sommerville here - I'd never heard of him until this whole contretemps, but I'm given to understand he knows a thing or two about design. Perhaps if he really stuck at TDD, Bob Martin's favourite bit would flip[1]. For less experienced programmers, who have not yet felt the pain of maintaining a ball-of-mud and learned a thing or two about separating concerns, TDD…

http://blog.8thlight.com/uncle-bob/2013/09/23/Test-first.html Read that and read oldie, but goodie Extreme Programming Explained, and IMO they do a good job of painting the bigger picture. TL;DR Tests are live specs that break when you change the underlying spec of your code without updating the spec in the test. If you can express your code's spec in a test, then you have a much higher chance of deeply understanding your design... hence the article's recommendation that you first know what you are doing before diving into writing tests. As for tests in the larger practical sense vs. the trivial... The vast majority of large systems are compositions of small, seemingly trivial pieces. A large system's code needs to be organized so that all its component pieces/concerns are comprehensible and separate; otherwise, it's an unmaintainable monolithic soup. The unit tests adhere to the same principle, in general, and follow the composition of the system.

I want to shine some light on one side problem, scratched here: The problem today is (out of the perspective of a developer): To many companies rely on just "hire any (cheap) developer" to ramp up the product. I see it all the time: Quality is not asked for, many companies (specially in the web business) just want the cheapest developers. They search for a student (at best), because he is cheap and will just make a small time estimation and an even smaller fixed price offer for the project. The student will happily work overtime that is not covered by the initial estimation. Than the companies go mad, when either the programmer is running away or the whole project runs into a blind alley (or both at the same time), because the "totally expensive" programmer had not enough experience e.g. with database development and the database structure just lets you shiver. Then the shouting and anger is big: "Damn programmers -- all are liars and lazy!" What went wrong, stated Uncle Bob correctly in his Blog: http://blog.8thlight.com/uncle-bob/2013/11/19/HoardsOfNovices.html But the "cheap, cheap!" culture seams to be unstoppable. If you tell people in advance about "quality" and "professionalism", they don't listen or just laugh at you. It seams, all the people just have to find out the hard way -- but I guess, even than most of them will not learn at all.

Wait, since when TDD become a best practice? I know this author is advocating it, but has 0 (zero) solid data or evidence to back this assertion. He is just trying to sell another religion. What I have noticed, TDD is being pedled heavy by RoR contracting shops that just care about billable hours and not vested if the startup or company is going to make it on the long run. I see often that it is the usually youngish and guidable engineers that fall in the trap of eating it up. TDD is something that makes younger and less experienced developers feel good (more locs) and a false sense that the code is correct while there is solid data that even 100% unit testing coverage finds only 20% of defects, at best. Having shipped many world class products, and none of the processes that build those products had any resemble of TDD in them. So, to all the pragmatists out there feel free to ignore the advice on the article. I'd yet to hear a super successful startup that used TDD. Having Tested Code (which is a good goal) != TDD. TDD to me is putting the carriage in front of the horse. Anybody that have created large systems from scratch, TDD is a major slowdown on the refining process. Your job is to SHIP a working product. Testing is only a small part of it, and its positives should be considered alongside its negatives and side effects on the shipping timelines. Having worked for over 10 years in the industry I have to meet any great programmer that preferred TDD. I hate to…

Interesting. I didn’t know you could do this. I can see how this can come in handy. Apparently there’s dtruss as an alternative for OS X. https://8thlight.com/insights/dtrace-even-better-than-strace-for-os-x

8th Light is a software company that's been explicitly practicing apprenticeship for like 12 years https://8thlight.com/blog/ryan-verner/2019/01/15/evolution-of-apprenti…

A few years ago, I tried to use Core Erlang as a compiler backend. It's fairly straightforward to learn even without thorough documentation. I wrote a bit about my process to try to help the next person [0]. For my particular project, I ended up abbandoning the approach and generating BEAM bytecode instead [1]. That was definitely more challenging, but it was neat to see Erlang's commitment to backwards compatibility in action. I believe that BEAM modules emitted by the first versions of Erlang are still valid on modern implementations. New functions are added and old ones are deprecated, but the actual file format version indicator hasn't changed. [0]: https://8thlight.com/blog/kofi-gumbs/2017/05/02/core-erlang.html [1]: https://github.com/hkgumbs/codec-beam

Relevant blog post in defense of generalists: "Jack of all trades, Master of One" https://8thlight.com/blog/makis-otman/2018/10/30/master-of-one.html

I watched the clean coder videos a few years ago and Uncle Bob said the exact same thing: the DB is just detail. I am not saying that he was right and I am not going to argue for his approach but it seems some of the big shots of the industry agree that DB is not central to the design. Also see: https://8thlight.com/blog/uncle-bob/2012/05/15/NODB.html > Databases and frameworks are details!

Some background about Core Erlang: https://8thlight.com/blog/kofi-gumbs/2017/05/02/core-erlang.html Core Erlang is an intermediary language targeting 'BEAM', the Erlang virtual machine.

8th Light offers an apprenticeship (multiple months of paid learning): https://8thlight.com/apprenticeship/ So does Pillar Technology: https://pillartechnology.com/dist/assets/careers/pillar-apprenticeship…

Ultimately, agile was successful[1]. Most companies took up many of the good practices. It didn't cure all our problems because coding is hard. [1] https://8thlight.com/blog/uncle-bob/2013/12/10/Thankyou-Kent.html

I think this is a good example of Spec being used to guide the solution http://gigasquidsoftware.com/blog/2016/05/29/one-fish-spec-fish/ I don't think Spec alone removes the need for mocking, using Clean Architecture is probably more important for that https://8thlight.com/blog/uncle-bob/2012/08/13/the-clean-architecture.… If you structure your app so that any IO lives at the edges, it becomes possible to test all your business logic without mocking. Spec can help at that point by providing generative testing. Since Spec

> Surprising this has been written in 2017. It looks like java written a decade ago. Clean Architecture™ has been around for a while now; I wouldn't be surprised if it was more than a decade already. This post is a guide to an existing concept, not a presentation of something new. EDIT: This is Uncle Bob, 5 years ago: https://8thlight.com/blog/uncle-bob/2012/08/13/the-clean-architecture.… So maybe it's just 5 years old - but then there were similar things (like Hexagonal Architecture) before.

There is a whole movement around this called Software Craftsmanship. There are a lot of companies involved and typically they are using the apprenticeship model to bring on new employees and grow the company. The one I'm most familiar with is 8th Light which started in Chicago but is now in Los Angeles, London, and New York City too. Their approach is more spend 5-9 months having the apprentice do mostly directed self-study, then a kind of final project and other work and, if they pass, an offer of employment. It's a really interesting model that seems to have worked well for them -- they attract developers from both traditional backgrounds and non-traditional. They have a page that goes into what apprenticeship means to them here: https://8thlight.com/apprenticeship/

Would these be cases where Robert Martin's 'The Clean Architecture' [1] would help, where the core enterprise logic is separated from third party dependencies, making the latter easy to swap out and replace? I'd imagine a number of these cases are caused by a heavy reliance on third party technologies that are no longer supported, or very few people still understand. [1] https://8thlight.com/blog/uncle-bob/2012/08/13/the-clean-architecture.…