I've never sent any hardware into space, but some former colleagues of mine were working on OWL around the time I left: https://asd.gsfc.nasa.gov/archive/owl/science.html
298 karma · joined September 17, 2019
I've never sent any hardware into space, but some former colleagues of mine were working on OWL around the time I left: https://asd.gsfc.nasa.gov/archive/owl/science.html
It was extremely expensive, and commercial, I'm honestly surprised I could even find a website for it.
It was extremely cool to basically scroll through memory, our hardware had an on-board FPGA that gathered waveforms from a photomultiplier tube attached to a scintillator, and when I was writing the driver for it, I could watch the memory in real-time with the debugger changing.
Setting initial values of memory to something like 0xDEADBEEF, and using this thing, was an incredibly powerful debugging strategy, especially when dealing with hardware.
I have a good friend however who is a great writer, and who has written a lot about her experiences, and who is working there again: https://www.jamiezvirzdin.com/
She didn't work much on the software/hardware side of things, however.
Maybe one day I'll sit down and put some of it to paper, I definitely have a lot of stories to tell.
I cut my embedded development teeth writing device drivers and custom firmware targeting it.
The reason we used SH4 is because the Dreamcast had failed, so there was a huge surplus of them available on the market at the time.
It was easily one of the most interesting and rewarding projects of my life to work on.
I worked on a Physics experiment almost 15 years ago, there were inklings of Python dripping in to doing numerical analysis.
NumPy just using existing Fortran libraries is a good example of it just being bootstrapped by the scientific community.
Most of these guys come from a Fortran background, and some used the C++ ROOT framework.
Ruby was just too alien for them.
ROOT had made some excellent Ruby bindings, and I spent some time showing some of my colleagues how much time they could save using them, but they just found it to be too different.
It's sort of funny to think, because languages made for AI originally like LISP used functional concepts like map, collect, etc etc...
I think the AI trend using Python was boosted by numerical analysis/computing libraries already being present.
I just think if a candidate scores a 70%, I don't expect them to be better or worse than a candidate who scores 100%.
Having criteria to perform an interview is one thing, but if your interview is just to go in with another toy challenge on a whiteboard, I think it would be much better to do a demo project, and immediately pair-program before making the decision to hire.
But you can't fault me for plugging CoScreen ;)
Hi, Jason here, CTO of CoScreen, and author of this article.
Thanks for your candid opinion Richard.
> The reality is that the Leetcode style coding interview, as we know it today...
I'd love a guide, or other details about how to best pose a "Leetcode" style interview, and refine it. It sounds like a lot of work, but I'm sharing my personal experience interviewing engineers over the last 20+ years. I don't pose just hackerrank like challenges as the only method, but also whiteboard/and ad-hoc in person interviews.
I'm willing to believe there are ways to get better results using these async type methods. But, for my last several companies, including being in management/hiring positions for several startups, I have found them to be very poor at predicting on the job performance.
> In the author's eyes, he thinks that more weight should be given to the soft skills.
I never stated this. I'm not sure where you are getting this from.
Being able to read code isn't a soft skill, nor is being able to navigate large code bases, debug, read documentation, and research. Absolutely these are skills that you can learn on the job, but not by any means easily.
> And different companies have different needs. When you're a startup, you need to code fast and quick, ship the product, and iterate.
I definitely agree with this.
> That's what allows companies to be efficient with their hiring: people are interchangeable.
Have you been working for software companies where you found engineers immediately fungible and replaceable?
This is really different than my own personal experience.
> And how could you do this effectively at scale without screwing over your own company's resources (again, think startups. Only so many engineers to go around.)
My experience hiring has primarily been for startups, and in both Director/CTO, and other positions, have had to spend an inordinate amount of time hiring developers. Scaling to three, or four engineering hires isn't difficult for a startup.
The cost on the other hand, to the point I made in this article, of making those two or three hires bad hires, is extremely high.
> without going into Leetcode would be the company to put a probationary period on new-hires.
Most good programmers are gainfully employed, and won't agree to a probationary period when being hired... Why would they leave a stable role for one that is tentative --- I wouldn't...
I think the onboarding project (could be paid/contracted) like I suggested in the article, as well as a pair-programming session, is what I am suggesting here. You could think of it as a commitment free probationary period on both sides, without requiring the engineer leave their current position.
> But if a bunch of smart and successful engineers can consistently land offers, then why can't other smart and successful engineers?
I'm not sure, really, I'm just offering advice for startups, like mine, that is earnest and based on my own experience.
>Leetcode interviews and his thesis would actually screw over smaller companies.
I don't really mention leetcode once in my article, and mention other forms of traditional interviews--- like in person whiteboard interviews... I call out doing hackerrank challenges.
I'm not sure why you're so focused on leetcode.
If I would have based my hiring on hackerrank alone, I wouldn't have hired one of the best engineers I have worked with in my career.
These coding challenges really don't prove competency in software engineering, again in my personal opinion, based on a large amount of experience in this area.
It's fine for you to disagree with that, but as the Dude would say: that's your opinion man.
I don't necessarily agree or subscribe to all of these points, just found it interesting there was someone very passionate about the process of software engineering interviews who had made an entire website dedicated to it.
> but the exact problem scenario this hire had should have been caught.
I think if people weren't taking courses specifically training for engineering interviews, and common interview challenges, maybe this wouldn't be a problem. The truth is gamified programming challenges (commonly used for interviews) do not have a strong relationship to actual day to day programming skills, like reading code, understanding documentation, and doing research.
I suppose I'm just reiterating your point, but I'm not sure why you come to a different conclusion regarding the person I hired being slow reading our code, doing research, and setting up basic tooling being something such an interview process would weed out.
It didn't, and hasn't like I said, any more than a coin flip, in my personal (anecdotal of course) experience.
> I'm not sure how having them write/debug some slightly more complex code in IDEA vs an online Vim approximation is going to suddenly catch people like this?
It won't, if that's all I was suggesting.
I was suggesting good engineers may be being filtered due to duress in the interview being caused by poor tooling.
The real focus was having them do a small semi-real project of some kind, and then having a solid engineer pair-program with them.
This has proven to be a successful strategy for us.
So, this is about coding interviews for hiring developers, and it's more about the goal of hiring a good engineer.
Obviously evaluating them dynamically will be more heuristic, and less fair, but it has worked far better for me than using standard uniform async interviews.
And as you pointed out one of the authors had a strong background in smalltalk, and they chose Smalltalk for examples presented in the book.
In other words, they had smalltalk in mind.
It wasn't like smalltalk was some alien language none of the authors had ever heard of, or wasn't the subject of the book in any way.
I've dealt with a number of C++ based serialization libraries, and they always have serious downsides to the point I often end up hand serializing structures with one-off half-baked formats just like you, which is error prone and laborious.
It's hard for me to understand this perspective when a large portion of the foundation of modern software is built on OOP and design patterns.
If you crack open the Chromium source code, you're going to see Factory mentioned hundreds of times: https://github.com/chromium/chromium/search?q=factory
As well as singleton: https://github.com/chromium/chromium/search?q=singleton
Visitor: https://github.com/chromium/chromium/search?q=visitor
And the list goes on, and on.
This is true for V8, which underlies NodeJS, and is the engine that powers most modern JavaScript:
https://github.com/v8/v8/search?q=factory
V8 was designed by the same engineers who built the Java Virtual Machine, and what techniques did they employ to build this massive piece of software that runs the modern web? Object oriented design, and design patterns.
It's very probable people designing modern web applications for the FAANGs are not particularly aware of design patterns, or even maybe that MVC is a design pattern even if they are using it. It's possible many design patterns aren't useful for the types of problems they are solving, or could complicate matters if they used them haphazardly.
But the engine driving every single JavaScript program, is built on top of a behemoth of object oriented, design pattern laden, software, written by FAANG engineers that I promise you understand design patterns extremely well.
I'm not saying this is the end all, be all, of software design. Or that "modern" functional takes on software design (most functional languages and ideas predate OOP) aren't perfectly valid, or successful. Or even that they couldn't solve many of these problems.
I'm just contesting any dogmatic rejection of what has actually been one of the most successful branches of software design.
The original Design Patterns book was written with Smalltalk in mind, which was dynamically duck typed, and had functional features (code blocks), among other things that didn't come to Java or Python for almost a decade.
Perhaps some language features are comparable to and negate the need for some design patterns, like Visitor with multiple dispatch which is provided by Julia --- but most creational, and behavioral design patterns are more just techniques that are independent of most languages and language features.
I definitely dislike the flavor of these articles that paint design patterns as a toolkit to piece together to build programs, rather than recognized components of a sound architecture which can help you build and design software that can be more easily reasoned about and extended.
It does lend to people making rube-goldbergesque monstrosities without really thinking about the why behind the way they are doing things.
I do think there are patterns I have recognized while programming in Rust, Ocaml, and a number of other languages, which never have had a description lent to them; and it's nice to see design patterns being talked about again, beyond the hype of the 1990's.
It set me on the path of experimenting with Gentoo, Debian, and Ubuntu.
Redhat has some excellent engineers, and I have made heavy use in the past of eCos in particular for embedded systems --- I've never understood why they continue to make grand decisions that alienate their customers.
But I do also know from experience that walking the line of evolving language features in a compiler taking into consideration prior legacy decisions is extremely difficult.
I think more than it being a pissing contest, I interpret there are practical considerations the C++ Standards Committee is considering in terms of performance, ease of implementation, and interaction with legacy features.
So please don't take my comment here as a critique on Warp. I was responding to the sentiment "I like my terminal as it is and I don't feel the pain outlined in the problem statement."
As in I too feel this way. I recognize there are a lot of people who aren't me, and feel differently about things than I do.
I imagine the desire for configurability and customization is similar to the argument between Vim/Emacs and IDEs.
Some people love the customization, plugins, and building a tailored solution. Some people are going to love the out of the box feature set of something like Warp.
The core I was trying to respond to really, was "The pain I feel is performance," which I also strongly relate to, and I wanted to call attention to another excellent Rust based terminal, Alacritty, which really has excellent performance for those of us who like cobbling together our terminal environments.
It actually feels like I'm living less of my life in UIs these days, and more in the terminal than I did in the 90s/early 2ks.
I've definitely felt some performance improvement using Alacritty: https://github.com/alacritty/alacritty
It's pretty spectacular.
Radare2 has a plugin for using ghidra's decompiler too https://github.com/radareorg/r2ghidra
So you can get all of the terminal level unix like goodness of radare2, yet still get really great ghidra quality decompiler output.
My team in the past (which developed security device drivers), ended up splitting a lot of our observability logic into EBPF, which is basically using a verifiable memory-safe subset of C, which was pretty incredible.
Given he authored the D programming language, he is absolutely aware of the benefits of managing memory allocation, runtime checks for boundary overruns, etc etc...
It turns out when developing a kernel extremely fine, granular control, over memory is very important. And there are a lot of complexities that fall between the cracks of various architectures where a compiler and language having an extremely long track-record of behavior is helpful. The Linux Kernel folks have even gone as far as restricting the use of VLAs that were introduced in C99 due to unexpected side-effects and complexities that came from it: https://www.phoronix.com/scan.php?page=news_item&px=Linux-Ki...
I'm definitely interested in RUST, but it seems like everything is viewed through a RUST looking glass these days, and all answers and roads lead to RUST.
The Soviets were willing to put large amounts of effort towards scientific advancements and exploration with little obvious profit motive on the other side, and it spooked the US into funding fantastic levels of basic scientific research.
It's interesting to see the percent of federal spending on basic research has fallen off a cliff since 1989: https://www.gspublishing.com/content/research/en/reports/202...
The lion's share is by business now, which is more likely to invest in things that have more obvious immediate profit avenues.
https://discussions.apple.com/thread/250943808
It's clear they have hit a limit of what they could really do with Intel's top of the line processors from a thermal perspective, with the form factor they want to deliver.
Now I have sort of an expensive paper-weight sitting next to my M1.
I'm interested if AMD/Intel will respond with their own beefed up desktop profile RISC/ARM processors.