Show HN: Xmake, a modern C/C++ build utility - <AUTHOR> https://github.com/xmake-io/xmake <comment><USER2> a developer post a well rounded tool with documentation that was built with a lot of care. The comment thread is mostly about other tools or people dismissing the work done because another available offer is more popular or common.

When did "Show HN" threads became shark tank? Can people at least check and post about the tool itself instead of discussing CMake vs Ninja vs Meson?

<comment><USER3> >When did "Show HN" threads became shark tank?

From the 2007 announcement of Dropbox:

[https://news.ycombinator.com/item?id=8863](https://news.ycombinator.com/item?id=8863)

""" 1\. For a Linux user, you can already build such a system yourself quite trivially by getting an FTP account, mounting it locally with curlftpfs, and then using SVN or CVS on the mounted filesystem. From Windows or Mac, this FTP account could be accessed through built-in software. """

<comment><USER4> Does anybody actually use Dropbox anymore? Feel like it's a dead product.

<comment><USER5> I used to, until they blocked the public folder. The sync between my computers was nice, but for me the big feature was copy/pasting (or directly creating) an image or static html page(s) with images (or flash files, at some point) in the public folder, right clicking in Explorer/Finder (depending on the OS i used at the time), copying the URL and pasting it on IRC/IM/Reddit/whatever when discussing stuff.

They tried to sell their 'get public URL' wrappers as the replacement for the functionality, but that only covered a tiny aspect (and OneDrive, Google Drive, etc already offered that stuff) - sharing photos - and even that was slower due to them wrapping the files in some sort of viewer instead of giving the raw file data like the public folder did, while using some sort of hash ID to identify the file instead of the actual filename (this was another convenience lost since with the public folder i could guess the URL to share without copy/pasting).

I never found anything as convenient as Dropbox's public folder while the rest of their offering wasn't anything i cared much about and even then by that time both Google and Microsoft's offers were better (and with Microsoft's available right out of the box in Windows).

<comment><USER6> I agree with the public folder issue. In my experience they still sync much better than OneDrive and Google Drive though. For me the syncing is a lot faster and has less issues.

They are also the only ones I know that have a Linux application.

That being said I don't pay for their premium service because it seems to expensive compared to OneDrive and Google Drive.

</comment></comment></comment></comment></comment><comment><USER7> Meson[0] has been gaining in popularity and has migration tools for cmake projects.

Large projects such as systemd and gnome[1] have migrated or have been migrating for years

[0] [https://mesonbuild.com/](https://mesonbuild.com/)

[1] [https://wiki.gnome.org/Initiatives/GnomeGoals/MesonPorting](https://wiki.gnome.org/Initiatives/GnomeGoals/MesonPorting)

<comment><USER8> Why migrate from CMake to meson?

<comment><USER9> CMake feels a lot like C++89: Lots of things you can do, but there are problems:

* No standardization or opinionated design, so you can't share your work easily.

* No sane defaults, so your build system is always fragile, difficult to maintain, and done wrong.

* No best practices, so people keep making the same mistakes over and over.

* Misguided attempt to remain compatible with the steaming pile of legacy they've accumulated over the years.

* Bad documentation, so there's no way to learn how to do things better.

* Steep learning curve with limited payoff, so most people don't bother.

Meson does some of these things better. It's still not pretty, but it's nicer to use than CMake.

<comment><USER10> 1 and 3 are not true anymore, the new canonical CMake way is targets with attached dependencies, header file search paths, compiler flags and possibly other things. Bad documentation - well yeah, it's specifically missing first- party best practices and howto documentation and the third-party documentation as well as really old first-party documentation in the CMake wiki often recommends bad old practices.

You forgot to mention that the language is awful (but that usually doesn't get in the way IME).

</comment></comment></comment></comment><comment><AUTHOR> We can see an example about xmake.lua

[https://github.com/tboox/tbox/blob/master/src/tbox/xmake.lua](https://github.com/tboox/tbox/blob/master/src/tbox/xmake.lua)

</comment><comment><USER11> What I miss about these tools is some "relatively" straightforward dependency detection and generation.

That is, I have a bunch of .cpp files which need to be compiled into individual executables in a folder bin/. I also have a folder inc/ which contains some headers (.h) and those headers possibly also have some associated TU (.cpp).

Now g++ can already generate a dependency graph of headers for an executable. It is then (with a standard Makefile and some supporting bash scripts) quite straightforward to mangle that graph into a list of translation units (namely those files whose name matches a depended-on header) which must be compiled and linked into the executable.

That is, I can simply create a new "executable file" .cpp file in bin/, include some headers therein and when I say make, the Makefile automagically figures out which (internal) dependencies it needs to link in when linking the executable.

Now that I have these "relatively straightforward" scripts and the corresponding Makefile, the incentive to move to another (nicer) build system which would require me to rebuild this infrastructure to fit into this other build system's view of the world is quite low – unless there is some way to do this directly?

Xmake as shown here (and also Meson linked in a sister comment) appear to still require manual selection of dependencies.

<comment><USER12> How would a tool know from a header dependency, in which source file the implementation for the header lives? C or C++ don't require any relationship between a declaration file and implementation file. The implementation could be in an entirely differently named source file, or spread over various files, mixed with implementation code from other headers, or included right in the header.

<comment><USER13> Generating automatically the dependencies is trivial with gcc and GNU make, if you just take care to group adequately in directories and subdirectories.

I.e. you just have to put all the source files from which you generate object files that will go in the same libray in a set of directories which does not contain files that will not go there.

Similarly, all the source files for the object files required for an executable, except those that are in libraries, should be in a set of directories.

The sets of directories need not be disjoint, just a given set must not contain files that must be excluded for linking a certain target, as that will make the building process more complex.

Given this constraints, it is possible to write a universal GNU makefile usable for any project, which will generate automatically all dependencies.

For any executable or library you want to build, it is enough to write an extremely small makefile, containing 4 lists (of defined symbols, of source files, of directories with header files and of libraries) and the name of the generated file and its type (excutable, shared library, static library).

At the end you need to include a makefile that is good for any project targetting a certain CPU + operating system combination.

The makefiles per CPU/OS must define a few things, e.g. the compiler used and other utilities, option flags for all, locations of the tools and so on, then you include a unique makefile for all architectures and operating systems.

I have started using this method more than twenty years ago and I have never ever needed to write manually any dependency information.

Whenever I see the huge and intricate and impossible to maintain makefiles that are too frequently encountered in many software projects, I wonder how one is willing to waste so much time with a non-essential part of the project.

From my point of view, building easily any large software project is a problem solved a long time ago by gcc & GNU make, but for reasons that I cannot understand most people choose to not do it in the right way.

Of course having to use in 2019 a programming language which does not implement modules by any better method than including header files is something even more difficult to understand, but I still must use C/C++ in my work, as there is no alternative for most embedded computers.

<comment><USER13> Sorry, there are several typos in my message above. For most of them it is obvious which was the correct intended word.

However, one typo can lead to a confusion because an entire word is missing. In the 4 lists that must be written in the makefile, the most important list, as the other lists can be omitted, is the list of directories with source files (not a list of source files).

For simple projects the list will be reduced to a single source directory. Whenever you add, delete or rename source files, there is no need to edit the makefile of the project.

All changes can be taken automatically into account by GNU make, which can be instructed to scan the source directories for source files for all the programming languages that you use.

</comment></comment></comment></comment><comment><USER14> This is really great work, great documentation. It looks like CMake, but with a full featured scripting language.

<comment><AUTHOR> thanks!

</comment></comment><comment><USER15> Does it have any distributed build or caching support? That is my minimum bar for a C++ build system. ccache and distcc/icecc are too limited, you want something integrated with your build system directly.

<comment><AUTHOR> Distributed builds are being planned, but not yet implemented. You can see [https://github.com/xmake-io/xmake/issues/274](https://github.com/xmake- io/xmake/issues/274)

</comment></comment><comment><USER16> For better or worse though, CMake has won! Many IDE's including Visual Studio can directly work with CMake files. In addition, even Google which is famous for doing things their own way, has now added official, first-class CMake support to their open source C++ library Abseil [https://abseil.io/blog/20190402-cmake- support](https://abseil.io/blog/20190402-cmake-support)

If you are writing an open source C++ library, even if you support some other C++ build system, chances are you will also have CMake support as well.

While I have no doubt, xmake is easier to use than CMake (just having Lua over CMake's abomination of a language is a great improvement), the fact that so many libraries and tools already support CMake is going to make adoption an uphill battle.

<comment><USER17> Cmake won against the incumbent, which was autotools. Still it's still far from being an enjoyable tool, whose experience is made even worse by its god- awful docs.

<comment><USER18> Personally, I vastly prefer autotools, both as a user and developer. When I got to the point I needed some kind of build system, I found autotools much easier to learn than cmake.

As user, I find the experience with autotools to be much nicer as well. For whatever reason, the interface just seems more intuitive. I mean, ./configure --help will tell you basically all you need to know. An underappreciated bonus is that you don't have to install more stuff just to __build__ some program you might not even want. I've run into more than one project that required a specific version of cmake, which as luck would have it, was not the version packaged with my distro. This leaves you either building another cmake first or finding a tool/library that isn't so persnickety.

Given the choice between trying a project that uses CMake or or autools, I'll choose the autotools based project every time.

<comment><USER19> > An underappreciated bonus is that you don't have to install more stuff just > to __build__ some program you might not even want.

sorry what ? I remember hours in my younger years searching which Debian package provided autowhateverflavoroftheday.sh so that I could build $random internet project

<comment><USER20> > > An underappreciated bonus is that you don't have to install more stuff > just to __build__ some program you might not even want.

> sorry what ? I remember hours in my younger years searching which Debian > package provided autowhateverflavoroftheday.sh so that I could build $random > internet project

The whole point of Autotools is that distributed source packages can be built by themselves, without requiring any part of Autotools to be installed. They build even on obscure systems that don't have any working version of Autotools.

If you have to install autoanything to build a random project that uses Autotools, either you are doing something wrong, or the project is using Autotools wrong, or maybe the Debian package is using Autotools wrong.

That said, I know what you mean. I've had to seek out a number of different versions of Autotools just to get some things to build. But that is because a lot of projects and/or distro packaging blatantly uses Autotools differently than it's was designed to be used. I don't think Autotools should be blamed for this.

<comment><USER19> > That said, I know what you mean. I've had to seek out a number of different > versions of Autotools just to get some things to build. But that is because > a lot of projects and/or distro packaging blatantly uses Autotools > differently than it's was designed to be used. I don't think Autotools > should be blamed for this.

yes, it absolutely should be. If a tool is misused, it's generally because it's hard to use correctly. In contrast, if I see a repo with a CMakeLists.txt I know that it's going to be a simple cmake && make.

<comment><USER18> > If a tool is misused, it's generally because it's hard to use correctly.

Citation needed.

Tools get misused all the time. If I use a flat bladed screw driver as a pry bar/chisel/whatever, that doesn't mean the flat bladed screw driver is hard to use.

</comment></comment></comment></comment></comment></comment></comment><comment><AUTHOR> Here is an official dependency package repository for xmake. [https://github.com/xmake-io/xmake-repo](https://github.com/xmake-io/xmake- repo)

</comment><comment><AUTHOR> One of the purposes of xmake is to solve the problem of C/C++ dependency packages.

<comment><USER17> So is Conan's[¹], and Conan is already supported by cmake.

[¹] [https://conan.io/](https://conan.io/)

<comment><AUTHOR> xmake also support conan, and vcpkg/brew

</comment></comment></comment><comment> Iwan-Zotow cmake is NOT a build utility. It is dependency tracking and configuration utility

<comment><USER21> "CMake is an open-source, cross-platform family of tools designed to build, test and package software. CMake is used to control the software compilation process using simple platform and compiler independent configuration files, and generate native makefiles and workspaces that can be used in the compiler environment of your choice."

They would disagree with you.

<comment><USER17> Cmake is a makefile generator. The output of cmake is a series of makefiles. That's it. If you need to build a project and you don't have make, nmake, jmake or whatevermake in your system them cmake does nothing to get your project built.

<comment><USER9> CMake can generate:

* Borland Makefiles

* MSYS Makefiles

* MinGW Makefiles

* NMake Makefiles

* Unix Makefiles

* Watcom WMake

* Ninja

* Visual Studio projects

* Green Hills MULTI

* Xcode projects

And more: [https://cmake.org/cmake/help/latest/manual/cmake- generators....](https://cmake.org/cmake/help/latest/manual/cmake- generators.7.html)

<comment><USER17> > CMake can generate:

Although you're conflating project transcoders with makefiles, nevertheless that's the whole point of cmake: generate makefiles that are used by some third-party program to actually build the software.

</comment></comment></comment></comment></comment><comment><USER22> Does it produce hermetic builds?

<comment><AUTHOR> What's hermetic builds?

<comment><USER23> Hermetic Builds. ... Our builds are hermetic, meaning that they are insensitive to the libraries and other software installed on the build machine. Instead, builds depend on known versions of build tools, such as compilers, and dependencies, such as libraries.

Kind of like a container for building? I had to look it up myself.

<comment><USER24> How would it do that besides building in a container?

<comment><USER25> Look into bazel, pants, and similar hermetic build systems.

You pin all dependencies and manage flags and such but via the build system.

</comment></comment></comment></comment></comment><comment><USER26> mmh. cflags and cxxflags are command line options ? i would expect them to be defined as part of build file.

<comment><AUTHOR> You can also define them in build file (xmake.lua)

        target("test")
            set_kind("binary")
            add_files("src/*.c", "src/*.cpp")
            add_cflags("-fPIC", "-Dxxx")
            add_cxxflags("-fPIC", "-Dxxx")

The command line arguments just give you a quick and easy way to modify cflags.

</comment></comment><comment><USER27> I wish CLion supported this as an alternative to CMake for project definitions!

<comment><AUTHOR> You can try clion/idea plugin for xmake.

[https://github.com/xmake-io/xmake-idea](https://github.com/xmake-io/xmake- idea)

</comment></comment><comment><USER28> Im not a fan of LUA. The syntax of XMake.lua reads somewhat like CMake but easier to understand. What I'd really like to see is a build system in Python (3!) utilizing objects and dictionaries for tasks like this should be a breeze.

<comment><USER29> Do you consider waf to meet that criteria? [https://gitlab.com/ita1024/waf](https://gitlab.com/ita1024/waf) [https://waf.io](https://waf.io)

Or scons? [https://scons.org](https://scons.org)

<comment><USER30> Does waf still force you to be c++11/14?

</comment></comment></comment><comment><USER31> Now we have N+1 incompatibile build systems.

<comment><USER32> I think half those N's are cmake itself considering the amount of time I see "requires cmake x.x or above" messages.

I wouldn't find having many build system such an issue if they'd just add a makefile (and maybe ./configure) to call that build system, giving devs a consistent interface and not having to lookup up how to do a simple build.

<comment><USER17> > if they'd just add a makefile (and maybe ./configure)

That's the whole point of cmake. Instead of running autotool's ./configure (which in fact is a whole dance involving autoconf, autoreconf, automake, and whatnot) just run cmake . to get yourself a fancy makefile.

<comment><USER32> > just run cmake . to get yourself a fancy makefile.

Well most instructions I've seen start of with "mkdir build && cd build && cmake ../src", which is a bit more complicated than just "make" with a default build dir. I'm not sure why they're all like this, I would have though supplying a default build directory is something cmake could handle.

My last and only big project with cmake we ended up with a makefile anyway to drive all the things cmake couldn't do, or that we couldn't do with cmake due to inexperience or some combination of the two. So we ended up with make calling cmake calling make, all because it apparently made it easier for IDE users (it didn't but that was definetly our fault).

<comment><USER33> I use Make to automate the initial CMake setup step - though by "Make" I probably mean something more like "glorified shell script", as the Makefile in question consists entirely of phony targets. It detects the OS with the usual bunch of ifs, and by default does one of 3 things:

\- Windows - generates a VC++ project

\- OS X - generates an Xcode project

\- Unix (other) - generates Ninja files for Debug/RelWithDebInfo

(Typically there's also the option to generate Ninja files on OS X if you like - good for automated build and/or if you'd just rather use some other editor (which is not unreasonable).)

Once it finishes, on Windows you load "build/vs2017/whatever.sln" into VC++; on OS X you load "build/xcode/whatever.xcodeproj" into Xcode; on Unix (other) you change to "build/Debug" or "build/Release" and run "ninja". And off you go. After that, it all just kind of runs itself.

The Makefile consists of basically stuff like this:

        .PHONY:unix
        unix:
                rm -Rf build/Debug
                mkdir -p build/Debug
                cd build/Debug && cmake -G "Ninja" -DCMAKE_BUILD_TYPE=Debug ../..
                rm -Rf build/Release
                mkdir -p build/Release
                cd build/Debug && cmake -G "Ninja" -DCMAKE_BUILD_TYPE=RelWithDebInfo ../..

plus some ifs to ensure the right target(s) are available depending on host OS.

(I've found it beneficial to regenerate everything entirely from scratch each time in the Makefile - ensures you're always working from a clean slate, with no cached variables sticking around from old runs. The odd package does have an unusually time-consuming configuration process, but I've always ended up managing to bypass these somehow - it's possible a future revision of my "process" will have to actually address this properly.)

This process does confuse people that don't read the instructions, as they type "make", some stuff happens, and then nothing. But I've found it to work well enough.

</comment></comment></comment></comment></comment><comment><USER34> I really love it! When did you start the project?

</comment><comment><USER35> What rubs me the wrong way is that a lot of build systems have a fatal combination of unfamiliar syntax and complete lack of debuggability.

Conan and Meson seem so much better in that regard.

<comment><USER17> Conan is orthogonal to the choice of build system, as in fact Conan's main choice of build system is cmake.

</comment></comment><comment><USER36> great!!

</comment><comment><USER37> This looks thoughtfully created (and so documented!). I haven't gone through the entire doc and am not particularly clear but can you cross-build too? How would you run MSVC linker on Linux?

<comment><AUTHOR> Support cross-build, but you need install mingw for linux, if you want to build win32 program on linux.

You can see [https://xmake.io/#/home?id=cross- compilation](https://xmake.io/#/home?id=cross-compilation) and [https://xmake.io/#/home?id=mingw](https://xmake.io/#/home?id=mingw)

</comment></comment><comment><USER38> Great!

</comment><comment><USER39> Don't ever install software by piping arbitrary remote scripts into bash.

<comment><USER40> Assuming the script is hosted on an https site, is a popular tool (like brew or rustup) from a trusted source, why would this be any more dangerous than downloading and installing from a a package manager?

What would it take beyond https and a well-known site to make _you_ comfortable doing this?

<comment><USER41> > Assuming the script is hosted on an https site, is a popular tool (like brew > or rustup) from a trusted source, why would this be any more dangerous than > downloading and installing from a a package manager?

Most package manager use an offline signature mechanism done at build time (rpm, dpkg, nix) and do not rely on HTTPS security for anything else than eyes-dropping reasons.

Relying purely on HTTPS is insecure. Nothing guarantee you that your source / script / package did not get hacked / modified between the time you uploaded it and the time your user downloaded it.

This is not hypothetical scenario, it already happened in the past with sites like sourceforge.

</comment></comment></comment><comment><USER42> It has an emoji in the title...I'm sold.</comment>


Ask HN: Why isn't there a professional body for Computer Science? - <AUTHOR> I know that people say that "interviewing is hard" and I've read lots of articles that say that people generally don't like doing long winded technical screens but it is the only way to judge whether or not a person is competent, etc.
What I want to know is why have other related areas of study such as Statistics, Economics, Actuarial Science and Operations Research been able to organize professional bodies that can determine competence. There are other professional bodies where they don't give credentials but they organize a central location for candidates and organizations to come together and they provide a standardized format to determine competence.
I find this especially baffling now that "data science" has become a buzzword. Lots of "data science" techniques such as:
- Generalized Linear Modeling
- Gradient Boosted Machines
- Support Vector Machines
- Random Forrests
- The Simplex Algorithm
- Anything with the word Bayes or Markov in the title
were developed by Statisticians/Mathematicians. Even though hospitals and insurance companies and the Fed and logistics companies are able to find statisticians/operations researchers/ predictive modelers/ etc. with out problems why do tech companies such as AirBnB(https://www.quora.com/How-does-Airbnb-hire-data-scientists) say they HAVE to give these multi-day long technical screens with multiple homework assignments?
What is it about applying the same techniques to tech that makes them special and some how harder to measure? <comment><USER3> It's an interesting question.

There is

[http://www.acm.org/](http://www.acm.org/)

which supports the academic CS establishment but frankly has a "devil may care" attitude about practitioners. CACM is full of hand-wringing articles about the roller-coastering numbers of CS undergrads and they never once get a clue that the undergrads hear rumours about what happens to people in computing once the flush of youth wears off. (It's a general thing that engineers start out with good pay but hit a glass ceiling rapidly)

I used to be a member but I quit because of this. If I had to point to a particular issue it is that the ACM has unquestioning support of increasing H-1B visas.

I am a member of the IEEE Computer Society precisely because they take the opposite side.

Personally it is not a litmus test for me, I see there are two sides of the issue, but when you look at the ACM they are in lockstep with the industry which sees it as a one-sided issue and anybody who questions it is like one of those brits that likes to brawl at football matches.

Anti-professionalism (that is, active opposition and resistance to professionalism) is the dominant paradigm in IT and it creates "market for lemons" situations that has a number of negative impacts on the field, the worst of which is that once you do get the job (well paid or not) you will almost inevitably be forced into malpractice by management and not have anybody to support you.

If there was a simple explanation of the situation it is that computing came along in a time when unions were on the run. Had computers became widespread 20 or 30 years earlier, the situation might be very different.

<comment><AUTHOR> How does that explain INFORMS for Operations Research?

WWII was the catalyst for a lot of technical research. It spawned the birth of the modern computer with Turing and it also saw the birth or what is now considered modern Operations Research. For example, during WWII George Dantzig (the person that developed the Simplex Algorithm) served in the U.S. Air Force Office of Statistical Control. He only returned to finish his PhD at Berkeley after the was was over. Also a lot of work with Bayesian search started developing around this time to do things like help search for enemy subs.

However INFORMS is very involved in the OR/MS community and multiple times per year they host meetings where one of the goals is to connect grad students with companies.

<comment><USER4> ACM and IEEE Computer Society also host meetings "where one of the goals is to connect grad students with companies."

When I was in school, the local ACM chapter had meetings which which even helped undergraduates find internships and jobs.

All of the major ACM conferences have a job fair. Most of the minor ones as well.

> "What is it about applying the same techniques to tech that makes them > special"

There is nothing special about tech. The same is true for most fields. Where is your central source where you can hire a chemist?

Usually, the potential chemist hire comes to the site, talks to people, gives a job talk, etc.

> "say they HAVE to give these multi-day long technical screens"

The link you gave to AirBNB says it's one day technical screen, and candidates which pass that screen have a followup with four non-tech interviews. It is not a "multi-day long technical screen".

<comment><AUTHOR> I guess the problem comes that especially outside of tech, they don't have independent technical screens, the company reads your paper.

If we stick with AirBnB here is a posting they made with the AEA ([https://www.aeaweb.org/joe/listing.php?JOE_ID=2015-02_111454...](https://www.aeaweb.org/joe/listing.php?JOE_ID=2015-02_111454432&issue=2015-02&keyword_search=&section=5&jel=all&country=all&recent_only=Show+all+listings+published+since+August+1%2C+2015&from=1970-01-01&to=1970-01-01&listings_order_by=institution_a&lpp=50)).

All of the interviewing takes place at the AEA meeting and the candidate is expecting to have their Job Market paper (a completed technical project that is used for presenting at all of your interviews).

The American Statistical Association has something similar with their Joint Statistical Meeting ([https://www.amstat.org/meetings/jsm/2016/employerlist.cfm](https://www.amstat.org/meetings/jsm/2016/employerlist.cfm)).

Once I finish grad school I wouldn't do any type of homework for a job interview. If you can't read one of my papers then I just wouldn't be interested.

<comment><USER4> The job process of hiring a new chemist is more than just reading your papers. And yes, _papers_ , as most people will have published several papers in the process of getting a PhD.

There are references to check up on. There's the ability to present your job talk; the ability to present is an important skill when you work in a company. Some candidates during the interview day might yell at a secretary or send text messages while being interviewed - these are two no-go indicators for most jobs.

Those two examples come from a comment at [http://blogs.sciencemag.org/pipeline/archives/2014/11/03/job...](http://blogs.sciencemag.org/pipeline/archives/2014/11/03/job_interview_advice) . Another points out a technical screening question one might ask a chemist:

> If I ask a PhD candidate how many protecting groups they know for nitrogen > and they can name ten off the top of their head with pros and cons for each > – then that tells me something. If all they can come up with is "Ummmm… > Boc?" – well that tells me something too.

[http://blogs.sciencemag.org/pipeline/archives/2006/01/29/nam...](http://blogs.sciencemag.org/pipeline/archives/2006/01/29/name_reactions_for_one_thousand_alex) suggests:

> I think I might work up some questions like that for the next time I > interview someone. "Here," I'll say, handing over a sheet of paper. > "SciFinder says that you can do this reaction any of these six ways. Which > one would you recommend trying first, and why?"

A recent grad comments about a job interview, with questions "more along the lines of "do you know some basic transformations and how they occur?"

Given that evidence that there _are_ technical screens for chemists, why do you write fields "especially outside of tech ... don't have independent technical screens", and that interviewers only look at one's single paper publication?

You write: "If we stick with AirBnB".

If we stick with AirBNB then re-read the interview process you linked to earlier. Not only does it not do multiple days of technical screening, as you thought, but it says nothing about a homework assignment; which seems to be a particular point of irritation for you.

You appear to have an incorrect interpretation of what you read, and an incorrect interpretation of what happens in other fields. I suggest that means you may need to re-evaluate what you think you know of the topic.

<comment><AUTHOR> I read the article correctly. They don't call it homework in the article and instead decide to use the term "data challenge". You can call it whatever you want it is the same thing. It is also split in to four parts and takes place over several days. How did I interpret this incorrectly?

I'm specifically talking about other technical fields that are highly mathematical and that have a lot in common with Computer Science.The fields that I specifically mentioned were Statistics, Economics, Actuarial Science and Operations Research. I mentioned all of the fields that I'm talking about in the original post and in sever of my replies. You are harping on something trying to correct a point that I'm not even trying to make and your response actually helps to further prove my point. You could be correct about the Chemistry thing. I didn't study Chemistry and I don't want to be a Chemist and I didn't mention the subject anywhere in my OP, so I don't really care about the interview process for hiring a Chemist.

For example, with Economics (one of the fields that I actually mentioned), presenting your "Job Paper" is actually part of the interview process. You make your presentation and everybody that has arranged an interview with you can come by and hear your talk. They can read your paper before hand so they have time to think questions well ahead of time. The American Economics Association provides one platform for all interested parties to come together and hash things out instead of me having to try and go to 10 separate interviews.

With Actuaries (another field that I actually mentioned) there is no need for you to quiz me to see if I actually know how a Poisson Process o GLMs work because that is taken care of by the exam process. If somebody passed the Statistical Models exam then you know that they at least meet the industry agreed upon minimum competency level for knowledge of specific Statistical Models.

<comment><USER4> I apologize. It was I who was mistaken. I overlooked that the basic question takes place at home.

This is, I think, equivalent to the FizzBuzz problem that was going around a few years ago. I can see how it can be called homework. I assume it's a screen because a lot of people apply who have no clue on what data science is actually about. If my assumption is correct, the it should take no more than 15 minutes or so, since it's supposed to be "easy."

You write now "and takes place over several days". Earlier you wrote "multi- day long technical screens with multiple homework assignments." These are two different, though related things. My response was to your first description, not your updated description.

Here are the differences I see. 1) the AirBNB text says "We send a few datasets to them and ask a basic question; the exercise should be easy for anyone who has experience." The use of 'the exercise' looks like it's one homework assignment, while you say it's " _multiple_ homework assignments". This is a minor point, but still a difference.

2) the AirBNB text says that the in-house challenge is a day long ("They then have the day ... At the end of the day"). That is the main _technical_ screen. The remaining day is a non-technical screen. I agree that it's a multi-day long process, but only one of those days is for technical screening. This is why I disagree with your initial characterization of "multi-day long technical screens", though I agree with your new characterization of "takes place over several days".

> "I'm specifically talking about other technical fields that are highly > mathematical and that have a lot in common with Computer Science. ... so I > don't really care about the interview process for hiring a Chemist."

I was addressing your earlier statement "What is it about applying the same techniques to tech that makes them special and some how harder to measure?"

In comparing your two sentences, I'm confused. You first imply that CS is "tech" and somehow special, and different from statistics and the other fields. But now you say they have a lot in common? What does "special" even mean then?

Most of CS, by the way, has very little mathematics in it. Surely less than chemistry does. Why do you think CS is "highly mathematical" when most CS departments require only basic calculus, discrete math 2, and perhaps an intro. statistics course? (Some specialized subfields of course require more mathematics.)

I'm "harping" on the topic because you think CS is somehow _special_ , when my experience from physics, chemistry, and bioinformatics says that the CS hiring method is pretty standard.

I believe the hiring process in mathematics is also similar to the science fields I just listed, and different from what you have described.

For example, [http://www.siam.org/pdf/news/1847.pdf](http://www.siam.org/pdf/news/1847.pdf) describes the process for "recent PhDs who are looking for positions at undergraduate-focused schools". It includes a strong teaching component, so the interviewees are expected to put together a talk with "the daunting task of showing that you can connect with an audience of undergraduates and non- specialists while simultaneously making it clear that you're a serious mathematician, knowledgeable about your area and with substantial work to your credit."

[http://blogs.siam.org/how-and-why-to-ask-good-questions- duri...](http://blogs.siam.org/how-and-why-to-ask-good-questions-during- interviews/) says "In the U.S., the typical interview for a PhD-level position lasts a full day or more, including a one-hour seminar and one-on-one meetings with researchers and/or faculty as well as managers/administrators." This is also different than your description of "You make your presentation and everybody that has arranged an interview with you can come by and hear your talk."

Am I incorrect? Is there a centralized system, perhaps at SIAM, for mathematics papers and job finding which is similar to what you describe for economics?

<comment><AUTHOR> I'm not sure about Mathematics, but for Statistics the American Statistical Association hold the 'Joint Statistical Meeting' every year. It is part continuing education classes, research presentations and career fair. Every year there are dozens of companies, universities and national research labs interviewing there. They also do a regular salary survey so you know what types of salaries are typical for Masters/PhD holders in different parts of the country and different industries.

If you plan working in predictive modeling at an insurance company you will have to get credentialed by one of the two actuarial societies. The SOA just added more exams to their current schedule to cover various predictive modeling topics and the CAS decided to make the predictive modeling portion a separate credential. But this way, you do everything once and it is valid across most English speaking countries. It doesn't matter whether you want to work at AllState, ESurance or Liberty Mutual. They just pull your record with one of the Actuarial societies.

I was saying that depending on what you specialize in they do have a lot in common. Given that you have similar specialties, why are economists and actuaries and statisticians able to judge a persons competence in some sort of standardized way but a tech company trying to hire someone in Machine Learning or Data Mining isn't able to do the same?

<comment><USER4> All fields have big yearly meetings as you describe. And people interviewing at them.

Including, as I mentioned, ones organized by the ACM and IEEE. Here's the ACM's stepping-off point for graduating students: [https://www.acm.org/education/resources-for- grads](https://www.acm.org/education/resources-for-grads) . They have a twice monthly publication called CareerNews. The ACM links to the many resources available for getting an idea of pay scales in different parts of the country.

At this point, I don't know what to say. Yes, a few fields have credentialed requirements, ranging from haircutter to certified public accountant to lawyer to surgeon to engineer.

Most do not.

For example, if you plan working in predictive modeling at drug discovery company, no such credentials exist. Moreover, a credential from an actuarial society will almost worthless, and surely less important than a MS in biostatistics.

You keep coming back to: "why are economists and actuaries and statisticians able to judge a persons competence in some sort of standardized way".

 _Shrug_ I know nothing about those fields. For all I know, it's because there is a well-known set of laws and regulations they have to follow, and generally accepted practices, so most of the need for competence is to ensure that people know those laws and practices.

That's not the case for most fields. Including computer science, in all of its forms and incarnations.

</comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER5> Perhaps because they're worried that the law would start requiring 'professional' accreditation to work in computer science?

Because at the moment, anything computer related is something you can teach yourself through practice and experience rather than something that necessarily needs a degree or credentials. You can obvious get a degree or what not, but it's not required.

The worry however is that professionalism could lead to a situation like with doctors or lawyers, where you need to be part of some professional body or have certain credentials to work in the field at all. And that it could make getting work in the field more difficult for newcomers as a result.

<comment><USER6> Worse, in order to belong to this body you might have some particular ideology shoved down your throat about how computers ought to be programmed.

We can't have a professional accreditation, because there is no right or wrong best practice in computing. Obviously, making programs that are buggy and incomplete w.r.t their specifications is wrong, but if you don't do that, there is no one right way.

<comment><USER7> Are there any industries with authoritative right or wrong best practices?

</comment></comment></comment><comment><USER8> We have ACM, IEEE, ACS, etc - so there are professional bodies, but ...

In my experience a very large proportion of programmers have not completed any formal training, which is typically the first step in the other professional accreditation processes.

The attempts to put real engineering into "software engineering" and real science into "computer science" is strongly resisted by many. ACM and IEEE deplore this state of affairs but are unable to bring about any widespread change in attitudes.

<comment><USER9> Well the fact is that the world needs software engineers and computer scientists, but it needs more _software developers_. Also software developers love calling themselves computer scientists and software engineers because money, and colleges don't want to teach _software development_ because...

<comment><USER7> > and colleges don't want to teach software development because

Because they don't want to admit they've become trade schools for white collar workers. They even advertise themselves as such, "training for the real world". The real world needs more software developers than computer scientists.

</comment></comment></comment><comment><USER10> I'm going to have to invoke the Munger test [1] on this: rather than imagining an ideal regulatory body that works perfectly, talk to people in regulated professional fields (law, architecture, medicine) and see what they think about the regulators they have.

You'll get a mixed bag. On one hand, it limits major acts of gross negligence where a practitioner really didn't know _a thing_ about what they were doing. In trade, you get a hierarchical, rigid career path where the people at the top -- the professionals/partners -- extract economic rent from those below in trade for their exclusive ability to practice the trade as independent professionals, not under control of anyone else.

Be careful what you wish for. Professionalization would probably benefit the old at the expense of the young, because salaries wouldn't necessarily track performance (or perception thereof) as directly as they do now, in tech. As controversial as it might seem, I really think there _is_ a limit of how much value one can add as an individual practitioner software developer, and don't think people should necessarily get, or expect, raises for doing the same job year in and year out, just for showing up. So you can either plateau salary quickly, which is what we have now, or hit the same peak, but take a lot longer to get there. It's a complex issue either way but I don't think the status quo is actually that bad.

[1] After economist Charlie Munger, invoked when people mention "the free market" or "regulation" to the solution to any problem. Think about the business leaders/regulators we have, not necessarily ideal ones of our imaginations.

<comment><AUTHOR> It doesn't even have to be regulated per se. For example, Economists aren't regulated the way that actuaries are, but they still have widely agreed upon format and process for how to get people from grad school to employment. It doesn't matter whether you want to work in the Econ department at Harvard, The World Bank or a consulting company like Deloitte.

</comment></comment><comment><USER11> Engineering professional associations could potentially regulate "computer engineers" here in Canada but as a student going through school (10+ years ago), I felt like the software industry wasn't ready for the rigor doing real "engineering". Everyone was getting ready to jump on the agile bandwagon which is pretty much the exact opposite of a formal engineering process. No one took design and security too seriously. They still don't. The industry and the markets pretty much agreed that they don't want to pay or wait for products to be engineered. That they can accept problems.. even serious ones like heart bleed.

<comment><USER12> And this sort of thing is why I'm against the idea strongly. The first thing that people think when they think about this sort of thing is that we have to drag in extremely heavyweight "better engineering", _blind to the major differences_ between programming and other engineering.

What if an architect could specify an entire skyscraper, push a button, and have it manifest in the real world in 30 seconds? What if they could slightly tweak something about the plumbing, push the button again, and have the old thing torn down and the new building put up? What if they could push another button to put 10 times the rated mass on every floor to see what happens? What if they could push another button to summon an 8.3 magnitude earthquake for ten minutes? What if they could write a for loop that did that for every .1 magnitude increment, ten times a day, until the building collapses, and gathered statistics on which buildings do the best?

Do you think maybe this would affect their design process a bit? Maybe just a little?

If you stop and seriously think about it, you should _expect_ that programmers have a very different optimum design methodology. It would be _crazy_ if we didn't!

Now, there are good practices and there are bad practices, and the bad practices are more widespread than they should be, and there are cowboys where there should be engineers. However, based on the prevalence of posts like this, I have little confidence in the ability of a "professional organization" to improve things. It seems based on the evidence far, far more likely to mandate _counterproductive_ practices that make software more expensive, less reliable, and harder for the disadvantaged and underprivileged to get into.

Don't be envious of the other engineering disciplines. _They_ envy _us_.

<comment><USER13> > _Don 't be envious of the other engineering disciplines. They envy us._

They shouldn't. Our work is deplorable. Any non-trivial internal codebase would probably give any mathematically savvy engineer nightmares for days. If our office buildings were designed as needlessly hastily the software designed inside them, having our tech hub in an earthquake hotspot would be a serious issue.

Yes, there is something to be said about the convenience of our "agile"/rapid- development cycle, but it's not like we use that power responsibly. We have enough decades-old codebases that have been in a perpetual state of 'fragile legacy-code' since they were first written, that prove that we don't take our designs seriously enough to improve them despite all our conveniences. If building engineers suddenly had access to some magical 'easy-bake oven' for building skyscraper MVP's and making 'agile' changes, I know I'd be concerned, looking back at our track record with software.

<comment> UK-AL Some the worst code I've ever seen comes from mathematicians and engineers.

They're objective is, does it work? Then don't change it.

You have to remember software is incredibly complicated due to the amount of possible states it can be in.

</comment></comment></comment></comment><comment><USER14> Because nobody saw the massive growth coming, and now it's too late.

Programming (which is different from CS, but is often mixed) is very accessible to learn (all you need is a computer and Internet), because of which it grew very fast and got democratized very quickly.

No professional body was able to catch up to the speed of growth and breadth of penetration. Before the talent crunch hit, it was too late.

I wish I could find some relevant numbers for growth, penetration and ubiquity of programming to support this claim. But for those of us in the industry for a while now (6 years of education + 15 years of working), there is a lot of anecdotal evidence. e.g. I was booed in 1996, for choosing CS as my major. And now every Taxi company out there needs software engineers.

</comment><comment><USER15> This industry doesn't need a union, but it does need a professional association to protect and help engineers. Some things a professional association could do:

1) Provide legal muscle to individual engineers - If there's a legal dispute between a company and engineer, the company can just outspend on lawyers. It doesn't matter if the law says the engineer is right, the engineer can't fight a long legal battle. This will help with issues such as non-competes, off- hours IP ownership, startup stock/options disputes, etc. It also provides a place for engineers to report issues such as H1B visa abuse.

2) Politcal lobbying - The voice of engineers is not heard in the H1B debate. This association could lobby and make sure the interests of engineers are represented in the debate.

3) Accreditation - No more stupid technical interviews.

I want to emphasize, this is NOT a union. It does not do strikes, set salary, or any of the things associated with unions. The primary power of an association like this is pooling resources for litigation power and political lobbying that serves the interests of engineers, not companies.

</comment><comment><USER16> There are a few, as people have pointed out, but why would they have any particular clout or influence in a marketplace dominated by the Church of MVP?

Practically every single piece of advice ever given about engineering and scientific practices on HN, or its cousin sites/forums, is that it's a pointless pre-mature optimization and should be avoided at all costs in favor of just hacking out and coughing up a piece of demoware that is loosely based on your slideware, both of which you're trying to sell to an audience that fundamentally doesn't care if it works or what its technical or scientific merits or risks are, and in that world I'm not sure where there's room for a vibrant and growing set of professional bodies because in that world the need for credibility benchmarks and verifiable rigor are almost entirely irrelevant.

</comment><comment><USER17> Tom Demarco (one of the authors of Peopleware [0]) argues that certification is primarily about the political agenda of the certifier/de-certifier, for example in a letter to the editor [1] of the Cutter IT Journal, the end of which I've clipped:

" Before ending, I offer the following example of how certification/de- certification will work: I hereby de-certify Prins Ralston, Nancy Mead, Patricia Douglas and Ed Yourdon. They will forever after have to write their names with the letters RTSF (Relegated To Slinging Fries) after them. This demonstration shows us two things about the process: 1) those who do the certification are always effectively self-appointed, and 2) the basis for de- certification, no matter what the societal rationale, always works out to be the private agenda of the de-certifier. James Bach and Luke Hohmann came out against certification in their article, arguing along the same lines I have used above. But I am going to de-certify them as well. This shows a third fundamental fact about certification: 3) it is inherently capricious, subject to all kinds of mischief. I vote that we let poor old Citicorp and poor old Aetna and poor old Microsoft figure out for themselves who they should hire. I suggest that we have a perfectly fine selection mechanism at work today; it's called the market. Some people get hired as software developers and some people don't. It is a lot more competent than any appointed elite would be and a lot more ethical."

[0] 'Peopleware: Productive Projects and Teams', Tom Demarco, Timothy Lister

[1] [http://www.systemsguild.com/certification.htm](http://www.systemsguild.com/certification.htm)

</comment><comment><USER18> THIS.SO.MUCH

Lets look at the salary of Actuaries shall we ?

£ 222,936 - Chief actuary, senior partner

£ 140,814 - Senior function head, practice director

£ 117,343 - Function head, practice head

£ 89,442 - Department manager, managing consultant

£ 80,664 - Section manager, senior consultant

£ 73,043 - Section leader, consultant

£ 66,118 - Senior actuary, junior consultant

£ 52,067 - <USER2>

£ 36,241 - Student actuary

£ 33,130 - Recent graduate

Each level is incremental - X amount of work increases your salary by Y amount.

All you need to do pass the exams and you can work in USA + Canada + Europe + India + Australia !

Now being a Chief Actuary is quite improbable - but look at the salary ! how probable is it that a programmer is going to earn that much after 25 years of experience ? we have all heard stories of unemployed experience engineers.

Coming from a maths background I really want some answers as to why I choose software engineering

To me the rampant unprofessionalism, the lack of structure, the insane amount of discrimination that is normal due to age, race, gender.

I really want to rage quit and go back and became an actuary due to lack of options for career progression.

<comment><USER19> Move to the US, seriously.

For reference, starting compensation for a 22-year-old fresh CS graduate in the Bay Area is $120k+ (higher than department manager in your list). 5 years in as an individual contributor or tech lead you'd be doing $150-$200k. My roommate was in actuarial and got the hell out when he saw the difference. Now he's a 'data scientist' and doesn't need standardized exams or accreditation to get a job.

<comment><USER18> Not every software engineer has the fortune to be born in the USA :(

<comment><USER20> Being born in the USA is not a requirement for getting a job as a software engineer in the USA. It's hard, but not impossible at all.

<comment><USER18> Recent Graduates do not have the experience for companies to risk going through the hassle of getting visa in america.

The way it works it seems is that companies are willingly to take the risk if you have proven yourself very well outside of america.

<comment><USER21> I'm pretty sure the opposite is true. It's much easier for a recent CS graduate to get a job offer in the US, than for anyone else.

But I agree somewhat, that software engineering is not the field, where you are likely to be able to have a career.

</comment></comment></comment></comment></comment></comment><comment><USER22> I'm not sure that accreditation is so widespread. Most engineers don't get licensed. Most math majors (myself included) don't take the actuarial exams. Many people doing math and engineering related work (and programming) have degrees in the physical sciences (again, myself included).

Engineers have an "industrial exemption," where they can work without a license, if they do engineering for an employer. Rather than having things designed by licensed engineers, the work is completed, and then a licensed engineer signs off on it. Design review is often outsourced. For instance when we're ready to ship a product (an electronic measurement instrument), we hire a testing firm to approve the design.

Better watch what you ask for: If you look at the actual work that licensed engineers do, most of us would say that it's incredibly repetitious and boring -- basically poring over someone else's work all day long. I'd go nuts. I also couldn't be a patent lawyer for that reason. On the other hand, it's well paid and secure. A relative of mine had a long and rewarding career as a licensed nuclear power plant operator. In practical terms, he was a project manager.

New things are developed and become widespread before professional bodies can even react. I learned about microcomputers under the mentorship of my physics professors, while the CS department at my college was 100% mainframe focused. The CS majors laughed at my "toy computer." The early pioneers of Embedded Systems were a hodgepodge of scientists, engineers, hackers, and so forth. How long would industry have waited for a certification in Embedded Systems?

I think the multi-day-long technical screens are a separate issue. Tech companies have gotten themselves utterly freaked out about the terror of hiring the wrong person. Other industries don't have the same problem because they don't follow the same trends, and it could change overnight if tech companies get sick of it.

<comment><AUTHOR> You obviously wouldn't take an actuarial exam if you don't plan on working in Insurance. However, if you do plan doing something like predictive modeling for an insurance company then it would have to do it.

Both the SOA and the CAS recently changed their exam process to include things like various predictive modeling and clustering techniques. The SOA decided to extend the number of exams and the CAS decided to make it a separate certification.

</comment></comment><comment><USER23> The book "Computer Boys Take Over" by Nathan Ensmenger ([https://mitpress.mit.edu/books/computer-boys-take- over](https://mitpress.mit.edu/books/computer-boys-take-over)) is a useful reference here. It goes through the early history of computing discipline and discusses how computing turned into a discipline, including professional organizations (including ACM, but also more "data processing" \- think COBOL - oriented organizations). It also makes some fun points on interview process (tldr - it was broken even in 1950s :-)).

There are too many points in the book to summarize in a comment, but anyone who wants to read some - at least to some point - serious historical work on the topic should probably have a look at the book.

</comment><comment><USER6> There can't be a professional body for Computer Science because Computer Science is a mixture of religions, divided by such boundaries as programming languages and operating systems.

Any sort of test to determine professional membership eligibility will either have to be pure theory (useless) or else sectarian (favoring practitioners who develop under a particular platform, or using particular approaches).

</comment><comment><USER24> Perhaps it has to do with the myriad sub-specialties in Computer Science. They are distinct enough that the specific knowledge and experience of one is typically not transferable to another. I am thinking about such distinct specialties as electro-mechanical control systems vs. A.I. You wouldn't expect the controls pro with no A.I. experience to pass an A.I. interview simply on the basis of his general computer science experience. Same for a CICS programmer with no mobile experience interviewing for a Swift programming position.

This fragmentation implies that Computer Science really is too broad an umbrella. For sure, there is a lot of process related general software development knowledge that all of the above should possess. But most projects won't suffer an experienced developer's learning curve on a new sub-specialty, even if it only means a few months.

Do Statistics, Economics, Actuarial Science and Operations Research have a similar attribute?

<comment><AUTHOR> All of the above do have various sub-specialties. The problem is that even the CS specialties (A.I./Machine Learning/Data Mining) still don't really conform with the other fields that I mentioned. Generalized Linear Modeling is Generalized Linear Modeling; it really doesn't matter whether you are classifying risks for an insurance company or classifying text documents at some tech start up. The math works the same.

In addition to that all of the other fields that I mentioned have sub- specialties as well. An actuary can be a life, health or P&C actuary. They can work in reinsurance or predictive modeling. An economist can work in Financial Economics or Labor markets or Econometrics/Quatitative Methods.

Yet the SOA/CAS are able to come up with and evaluate a set of minimum competencies that insurance companies in most English speaking countries are able to agree on. The American Economics Association is able to bring together major international banks (Various branches of the Fed, The World Bank, Various National Banks, Consulting Companies, Law firms that specialize in Financial/Economics issues) and grad students and it gives them a common format to get to know each other and evaluate job offers regardless of a candidate's/company's specialty.

</comment></comment><comment><USER7> Aside from the individualist attitude that's prevalent, it's because we are still grouping too many things under the banner of computer science or engineering.

Neither of those disciplines has much correlation to general software development, so they fail from the start.

</comment><comment><USER25> Because the guild system is outdated. I don't want to be encumbered by a social environment of forced "professionalism", where professionalism means ponying up for some pointless self-inflicted bureaucracy.

<comment><USER26> > Because the guild system is outdated

Evidence?

<comment><USER27> The computer-programmer industry, for a start?

</comment></comment></comment><comment><USER28> I've been interviewing for the past month in SF. The only thing bad about my interviewing processes experience is BAD INTERVIEWERS with no sensibility to HUMAN SKILL (i.e. not technical skills).

Team fit is what makes people shine in their jobs and no one is asking about it... The industry is well developed now for us to stop asking about reversing binary trees and start asking about how many friends you one had in high school

<comment><USER29> > The industry is well developed now for us to stop asking about reversing > binary trees and start asking about how many friends you one had in high > school

Could you explain?

</comment></comment><comment><USER30> There is a strong streak of libertarianism, if not outright objectivism, in this industry which recoils at the mere thought of collective action.

<comment><USER31> And rightfully so. Who the hell are "they" to judge "my" competency?

Isn't that the job of my employer, anyway?

<comment><AUTHOR> For one thing, there is a reason that "The Professions" were standardized. At one point in history, there was way less regulation for a lot of professions. But then people had problems with insurance companies becoming insolvent and not actually being able to pay all claims when major disasters struck. This was because companies were hiring people that really didn't know how to do the math.

It also seems like it is also more common for actuaries, statisticians, Industrial Engineers to do independent consulting where they are employed as an independent professional and will be required to carry things like insurance. In cases like that, there really isn't any place that acts as "your employer". Instead, you are independently providing your services to a client.

<comment><USER32> We're one or two balls of flaming wreckage away from software development being controlled like other types of engineering, with certified training programs, P.Eng. signoffs, and formal apprenticeships.

Or if not flaming wreckage, then major corporate failures, particularly if they are banks.

It's coming. Just a matter of time.

</comment></comment></comment></comment><comment><USER33> > say they HAVE to give these multi-day long technical screens with multiple > homework assignments?

The only logical explanation I can this for this is because HR has to find something for itself to do.

Is there any evidence to suggest that requiring mutli-day technical screens reduces the rate of bad hires?

</comment><comment><USER34> No offense to the other fields, but as an outsider to those fields, I feel that computer science is a far more varied and creative field than math or statistics.

With programming, you can write programs that use statistical analysis and modeling. But you can write programs that do things that are far less mathematical in nature. A web developer could create a content-focused website, including the backend and devops code. If said developer is far more focused on the content and less on the code (e.g. not much more than setting up WordPress and writing CS/JS and maybe some custom PHP), why should they have to get accredited for that?

It's not that math and statistics are lesser fields, but that computer science (or rather, what's commonly associated with it, such as programming) is a far more versatile and creative field. The difference between being accredited to write a legal opinion, and being a writer in general. But we don't credentialize writing.

</comment><comment><USER35> Software Developers don't have one because there's so much money being thrown at them, and its increasing fast enough, that they don't feel the need to siphon any of it off for a professional organization.

</comment><comment><USER36> I'm in favor. Let's require professional accreditation to work in the industry, lobby against H1B, and get our salaries really jacked up!

<comment><USER37> I'm not in favor of pulling the ladder up behind me to screw over future programmers and benefit myself.

<comment><USER36> You're not in favor of sarcasm either. It's the more fun way of demonstrating the danger of professional bodies.

<comment><USER37> Sorry about that. Although I'm worried about the number of opinions I see on HN that are literally the sarcastic ones you expressed.</comment></comment></comment></comment>


Why open hardware needs open software - <AUTHOR> http://blog.snapeda.com/2019/10/28/an-interview-with-wayne-stambaugh-of-kicad/ <comment><USER2> As a mechanical engineer, I'm envious of polished open source tools that exist in other fields. For parametric modeling and engineering drawing of mechanical parts, the free software tools are not nearly as mature and user friendly as commercial equivalents. When creating engineering drawings and models for public use, I would much prefer to use free software such as FreeCAD, SolveSpace, and OpenSCAD, because I want designs to be modifiable by anyone.

Unfortunately, using these free tools feels like a throwback to a less developed era in desktop computer aided design. Commercial CAD software with no-cost hobbyist licenses are much more usable, but tie you into their licensing structure and cloud data system. There's no telling whether you'll be able to open your Fusion360 or Onshape projects 10 years from now.

I have a lot of hope that eventually free software will overtake commercial software in a lot of fields, and establish a regime where everyone has access to "professional grade" tools. Something like that exists in the information technology field, and it has unlocked a lot of human potential over the last few decades. Just imagine every school child having access to advanced, professional grade free software tools in every sort of field of human creativity.

<comment><USER3> Whenever a free CAD software exists, AutoCAD or similar buys them out.

I'm not sure the solution.

<comment><USER4> That's only really possible when there's a company behind it. It's much harder to buy out a whole OSS project, the only real option is to buy out the main contributors.

<comment><USER5> Especially like in the case of KiCad, some of the main contributors are CERN :D

</comment></comment></comment></comment><comment><USER6> Apart from well known KiCAD, I hope more open-source electronic design and engineering software projects will get attention from the industry. Software like LibreCAD[1] and FreeCAD[2], Qucs[3], gEDA[4], Yosys[5] and Symbiflow[6], Chisel/FIRRTL[7], OpenROAD initiative[8], Degate[9], and many others.

[1] [https://librecad.org/](https://librecad.org/)

[2] [https://www.freecadweb.org/](https://www.freecadweb.org/)

[3] [https://github.com/Qucs](https://github.com/Qucs)

[4] [http://www.geda-project.org/](http://www.geda-project.org/)

[5] [http://www.clifford.at/yosys/](http://www.clifford.at/yosys/)

[6] [https://symbiflow.github.io/](https://symbiflow.github.io/)

[7] [https://www.chisel-lang.org/](https://www.chisel-lang.org/)

[8] [https://theopenroadproject.org/](https://theopenroadproject.org/)

[9] [https://github.com/nitram2342/degate](https://github.com/nitram2342/degate)

<comment><USER7> LibrePCB is an up-and-coming contender that aims to do things right from the library-management perspective: [https://librepcb.org/](https://librepcb.org/)

</comment></comment><comment><USER8> I am one of the FreeCAD developper (vejmarie). I believe some good innovations are coming up within the next release. I recently added some Cloud features with storage capabilities directly to s3, opening doors to build a collaborative platform (I am working on a mockup). Waevfront OBJ exporter has been improved allowing some direct export to webGL format and many other things. Regarding the features, an assembly workbench is under work, and some fancy stuff have been designed with FreeCAD (there is some Renault Twizy design files available). The FeM workbench with OpenFoam bridge allows also to initiate some simulation model. FreeCAD has in its backend a lot of capabilities that we can expose to end user. We are lacking from good feedback on the UI other than we are not yet reaching Solidworks, but FreeCAD is today a solution which works on Mac, Windows, Linux, has an open file format (Brep shape and XML representation), and is fully open source. We made tremendous progress since version 0.16 and there is a strong wish to bring in innovation regarding design workflow. Just tell us what might be your best tools and we can try to do it !

<comment><USER9> As someone who uses FreeCAD on and off, I thank you very much for your efforts! There are a lot of features.

It is definitely not lack of features that holds FreeCAD back, though. It is the UI/usability/stability. In fact, I'd prefer a solution WITHOUT cloud features as it's a liability in my profession, and in general ends up putting an expiration date on the program (as eventually servers get turned off, etc).

Again, thank you SO much for your efforts.

<comment><USER8> You are welcome. The Cloud implementation I made, is fully compatible with the minio server which is an open source implementation of s3 written in Go, meansing that you can keep everything in house and this was something super important to me. FreeCAD is a huge piece of software. Thanks for your support ! I agree with you we change too much things but since 0.17 we moved to something more modular with new object which were reuired to implement a descent assembly workbench. This is done and I do not think this is going to change that much anymore (but who knows) ;) We will do it the best as we can for sure.

</comment></comment></comment><comment><USER10> I wonder if a joint hardware-software development project could benefit KiCad in a similar manner that the Open Movie Projects have helped Blender's development.

For those who don't know, Blender has developed a few complete animations/shorts with artists and developers working jointly, thus bringing in real world experience to the project.

I wonder if something similar could be done with an open hardware project.

</comment><comment><USER11> A few days ago wayne did post that his position was terminated : [http://kicad-pcb.org/blog/2019/10/KiCad-Lead-Developer- Annou...](http://kicad-pcb.org/blog/2019/10/KiCad-Lead-Developer- Announcement/)

<comment><AUTHOR> This is referring to WIT's funding. As per the post:

 _In the short term, I will continue working on KiCad while pursuing as many avenues as possible to generate enough revenue to allow me to continue to work full time on KiCad._

<comment><USER12> Who are WIT, anyway? Their site is a placeholder: [https://www.wit.com/](https://www.wit.com/)

<comment><USER13> Archive.org can help in cases like this, e.g.: [https://web.archive.org/web/20190517010832/https://www.wit.c...](https://web.archive.org/web/20190517010832/https://www.wit.com/)

</comment></comment></comment></comment><comment><USER14> I love kicad and use it daily.

One of my most wanted feature would me to be able to select a trace and get simulated electrical characteristics, like resistance, capacitance, inductance (for example to design a loop antenna, I integrated a few of them in my lastest PCB, for NFC, and had to calculate by hand)...

Of course this is not a small feature but wishing for that says a bit on how good kicad has become, there is very little small feature to wish for as most are here.

</comment><comment><USER15> At first sight the title seems to wrong, that software is easier to be open compared to hardware.

<comment><USER16> agreed; open hardware generally guarantees the possibility of open software, even if the product ships with closed software.

however; the interview is really talking about using open software to create your open hardware designs. if you've developed your schematic using proprietary software, then only people who have the same proprietary (paid) software can contribute.

another interesting point they touched on is open instruction sets (e.g. RISC-V). people are developing open hardware platforms with open software solutions but in the middle there is ARM or some other proprietary processor instruction set.

</comment></comment><comment><USER17> I've been out of the EE world for a couple of years now, but looking at the screenshots of KiCAD schematic capture tool, it looks remarcably simular to Eagle (same colors, graphics, etc). Are KiCAD and Eagle related in some way?

<comment><USER18> Nope, they're completely separate. Codebase, people, timeline.

Eagle predates KiCad by a wide margin, iirc. KiCad started in France, Eagle was German (iirc). I think modern Eagle is on Qt, KiCad uses wxWidgets for it's GUI library.</comment></comment>


Introduction to Metaprogramming in Nim - <AUTHOR> http://hookrace.net/blog/introduction-to-metaprogramming-in-nim/ <comment><USER2> I like the macros definitions. Those are very elegant. I use macros in Rust, but I don't find them very intuitive, or easy to get right. They are ridiculously powerful, but it feels like learning a new language, like there are three languages in Rust, safe, unsafe, and macros (don't get me wrong I love Rust, and enjoy it the more I use it).

Out of curiosity, could someone who's written in both languages, give their opinion on the differences between the two macro systems?

</comment><comment><USER3> Other examples of things one can do with metaprogramming: async/await [http://nim-lang.org/docs/asyncdispatch.html#async](http://nim- lang.org/docs/asyncdispatch.html#async) , pattern matching [http://andreaferretti.github.io/patty/](http://andreaferretti.github.io/patty/) , for/do comprehensions [https://github.com/vegansk/nimfp/blob/master/tests/fp/test_f...](https://github.com/vegansk/nimfp/blob/master/tests/fp/test_forcomp.nim)

<comment><USER4> ... define decorator-like Nim pragmas that generate Python C-API boilerplate code for decorated Nim procs, to auto-generate type-safe, exception-safe, refcount-safe Python bindings for Nim? [https://github.com/jboy/nim- pymod](https://github.com/jboy/nim-pymod) :)

<comment><USER3> Yes, I also wanted to add your library, but I was not sure how it works and to what degree it uses metaprogramming. But I am glad that you mentioned it! :-)

</comment></comment></comment><comment><USER4> For anyone unfamiliar with Nim, I'll give a quick summary of Nim generics, templates & macros, in terms of C, C++, Java & Lisp:

* Nim generics = parametrization-by-type of procs (functions) or other type definitions. Happens at compile time. Like Java generics or C++ templates, except that it uses [ ] rather than < >.

* Nim templates = direct textual substitution of code at the call-site at compile-time, like the C preprocessor, except that: 1. It operates upon a parsed Nim AST rather than plain-text code; 2. It's (by default) hygenic; and 3. The syntax is the same as regular Nim language syntax (in contrast to the crippled C preprocessor syntax).

* Nim macros = compile-time evaluation of code to perform side-effects, one of which may be inserting new code at the call-site. Nim macros are most like Lisp macros. An invoked Nim macro receives a parsed Nim AST as a tree data-structure, and is able to traverse & manipulate that AST, or create & output a new AST. When evaluating macros, the Nim compiler runs the macro code in a compile-time Nim interpreter, so macros can invoke any other functions, allocate data-structures, etc. And again, the syntax is the same as regular Nim language syntax.

[There's another Nim language feature that I really like, which I think is worth mentioning here: the `const` keyword, to define constants. Nim provides `var` to define variables that are read-write storage boxes, and `let` for single-assignment storage boxes. `const` is like `let`, except it's evaluated at compile time. This means you can evaluate arbitrarily-complicated expressions (including function calls) at compile time, obtaining the result as a constant of the appropriate result type, which can then be inlined at all usage-sites -- just as if you'd entered the literal value directly in your code.]

With this background in place, I can finally get to my main point:

When I'm getting excited about Nim to friends, I tell them that I think Nim macros are the best tradeoff between an expressive Python-like syntax & powerful AST-based, Lisp-like macros.

You see, no-one would dispute that it is very elegant to use regular function syntax to operate upon homoiconic code as a data-structure. And no-one would dispute that operating upon a pre-parsed AST is superior to crude text- concatenation (like in the C preprocessor). But as a commenter on HN pointed out in a recent thread about Lisp:

""" _So, the real question is why did such a magical language lose to the upstarts that all appeared in the late 80 's and early 90's: Perl, Python, Tcl, Lua, etc. Answer: files, strings, and hash tables. All of those languages make mangling text pathetically easy. Perl is obviously the poster-child for one-liners, but all of those make that task pretty darn easy. Lisp makes those tasks really annoying. Just take a look at the Common Lisp Cookbook for strings: [http://cl-cookbook.sourceforge.net/strings.html](http://cl- cookbook.sourceforge.net/strings.html) _""" \-- [https://news.ycombinator.com/item?id=11700176](https://news.ycombinator.com/item?id=11700176)

Dense language syntax is beneficial because it enables brevity for frequently- occurring operations. For example: string indexing, slicing & especially regex matching, if you do a lot of text-processing; inline arithmetic operators if you do a lot of arithmetic; and array operators, if you do a lot of matrix processing.

Nim's macros combine a dense (Python-like) language syntax with powerful AST- based macros, enabling you to traverse & manipulate the AST just like any other data-structure.

</comment><comment><USER5> As someone who's never coded in either go or nim, this seems to me to be the exact opposite ideology of golang. The metaprogramming is very cool, but I imagine sharing a code base that utilizes it heavily is a nightmare.

<comment><USER6> The difference is you or your team have the option to use the magic in moderation vs no magic at all.

<comment><USER7> I think only time can tell if that sort of argument works. Your team's habits matter, but so does the rest of the ecosystem. Strangers with libraries too central to ignore might end up forcing inscruitable templates and macros on you.

As far as I can see, the Python community has done a pretty good job of using magic sensibly. The Ruby and C++ communities, not so much.

<comment><USER6> Yes time will tell. Its basically like giving someone Jedi powers with the risk they could fall to the dark side while Golang is like Han Solo just getting things done in a much less sophisticated yet practical manner.</comment></comment></comment></comment>


How online security cards fails (or how security economics trumps engineering) - <AUTHOR> http://www.lightbluetouchpaper.org/2010/01/26/how-online-card-security-fails/

<comment><USER2> I am sincerely interested in hearing the arguments for why OpenID counts as "properly designed". I implemented it for my day job. The experience both as a relying party and as an end user is _miserable_ , and (though not relevant to our implementation) I question the security wisdom of teaching users that any random site on the Internet is going to ask for their Yahoo/Gmail password and that giving it to them is OK.

<comment><USER3> I am a major anti-fan of OpenID, but the idea is that these sites will _not_ ask you for your Yahoo/Gmail password. Instead, they will bounce you to Yahoo/Google/whoever (where it's assumed you'll usually already be logged-in), which will ask you for permission in a standardized, recognizable way.

My major objection to OpenID is that it takes a single-site registration/login experience, with one consistent look and feel, and throws two extra HTTP requests and a completely different look and feel into the mix. To me that makes the experience _more_ confusing and inconvenient, not less.</comment></comment>


A Genetic Programming Approach to Automated Software Repair.  - <AUTHOR> http://www.cs.virginia.edu/~weimer/p/weimer-gecco2009-preprint.pdf

<comment><USER2> Very interesting stuff. I did notice that this bug was due to a broken test procedure, a simple test loop during the initial write would have brought this problem out instantly.

If your code has an integer range of several 10's of thousands of input possibilities and it costs you next to nothing to run it why not exhaustively test that function?

That way your confidence goes up tremendously, just a couple of edge cases vs the whole range, I know which one I'd pick.

The run output would simply be two columns of integers, very easy to scan for errors. (the output should be equal or monotonous increase from day by day, and should not hang...).

Of course that's after the fact, but there is really no routine so trivial that you can get away without really testing if it does what you intended.

<comment><USER3> That's an excellent point - if you have a finite range, why not test all of it? - and I know software testing researchers who look into just that. The difficulty to keep in mind is that in a large code base, there are going to be many small pieces that have a different finite range.

<comment><USER4> You might try something like CUTE:

<http://osl.cs.uiuc.edu/~ksen/cute/>

</comment></comment></comment><comment><AUTHOR> Westley Weimer has a presentation on the same @ Stanford University today at 2pm (1 hr from now) in Gates 104

Map - [http://maps.google.com/maps?f=q&source=s_q&hl=en&...](http://maps.google.com/maps?f=q&source=s_q&hl=en&geocode=&q=Gates+104,+stanford&sll=37.0625,-95.677068&sspn=45.957536,93.076172&ie=UTF8&ll=37.430173,-122.172963&spn=0.001414,0.00284&t=h&z=19)

<comment><USER4> He is at Berkeley tomorrow:

[http://events.berkeley.edu/index.php/calendar/sn/eecs.html?e...](http://events.berkeley.edu/index.php/calendar/sn/eecs.html?event_ID=22841)

Attend if you can!

</comment></comment><comment><USER5> Don't get too excited, this requires unit tests to detect the bug. In other words, if you already have a pretty good understanding of the bug, this thing will evolve a fix for you instead of having to write it yourself.

If you can write an algorithm that _finds_ bugs, then you've really got something.

<comment><USER6> A bug is a defect. A defect is a deviation from the intended meaning of the program. To automatically detect that, you will need a formal specification of the meaning of the program.

It's the automated programming paradox. You can't automate programming because you have to tell the automaton what to program... which is called programming.</comment></comment>


Tina Fey chats with Eric Schmidt - <AUTHOR> http://www.itworld.com/offbeat/159785/tina-fey-chats-eric-schmidt <comment><USER2> I like the mention of the improvisation concept of "yes and" as being a huge influence on her professionally. She describes how this can take good ideas from two people and create something newer and better.

Some of the best collaborators I have had were of the "yes and" attitude while the worst were of the "no but" or "no because" variety.

</comment><comment><USER3> Fascinating. Somehow, I wouldn't have really expected it, but the sheer difference between someone like Eric Schmidt and someone like Tina Fey really made this interesting.

So I ask you: are there any other such Google talks/chats like this worth watching? I believe there was one from a while ago with Obama, but I haven't really heard of any others.

<comment><USER4> There are over 1000 videos like this in various forms: <http://www.youtube.com/atgoogletalks>

A lot of them are authors, but there are a bunch of other celebrities, musicians, politicians, and a ton of others. I'd recommend clicking on "Uploads" and then select "Top Rated."

</comment></comment><comment><USER5> I think this interview does a good job of showing just how easy people like Letterman and O'Brien make interviewing look.

<comment><USER6> at least they didn't have the same guy that interviewed Conan. <http://www.youtube.com/watch?v=u7TwqpWiY5s>

<comment><USER7> That would be Vic Gundotra. <http://en.wikipedia.org/wiki/Vic_Gundotra>

</comment></comment></comment><comment><USER8> Really interesting interview.

Tina Fey was very good; engaging, interesting, funny. Eric Schmidt probably shouldn't give up his day job to become a presenter.

The Google mentions and plugs seemed a bit nauseating. E.g. the fact baby names can be found via Google doesn't really need advertising.

<comment><USER9> In fairness, I thought he did a pretty good job. Better than I would have expected for a CEO :D and some of the audience questions were pretty good too.

I suspect he won't be going after Jimmy Fallon's job in 2020, though.

<comment><USER10> Yes I thought he was pretty good too. If you want a train wreck for a Google talk, look at Conan O'Brien's interview there -- the interviewer was cringe- worthy.

</comment></comment></comment><comment><USER11> They laugh so hard every time Schmidt makes any sort of joke. Bunch of zombies when it came to the Apple stuff.

</comment><comment><USER12> She has another fantasy unavailable BF? And this isn't 30 rock?</comment>