One difference is that a license is required to practice civil engineering. Most web developers, on the other hand, require large tools to do theirs jobs for them and recoil in irrational fear and disgust when standard DOM methods are used. I still have people argue with me that the DOM is slow even though all the evidence and browser vendors claim updates to the DOM is simply switching a bit in memory. In other words many web developers have utterly no idea how their platform works.
Another difference is that many developers cannot write. Everything about a bridge is planned in extreme detail before work on the ground ever starts. This level of planning is absent in software. Documentation is also largely absent. In most cases everything is an ad hoc mess. In any other industry this would be a cause of numerous lawsuits.
Another difference is that construction is treated as a business project with a dedicated project manager and project budget. Most business software, on the other hand, is treated as an operation. If you cannot discern the difference between a project (temporary) and an operation (living) your software will never be released as a product to a specified level of quality by a specific date.
However when I got into more creative development I found myself faced with unique problems to which the solution was unknown. The development process in this case is less like an implementation and more a exploration of the problem space.
This process is more like sculpting or writing a book or solving a puzzle. As you sculpt the next steps reveal themselves. As you write a story the plot emerges. In order to solve a puzzle box you probe the box.
Solving the unknown in bridge building is working through sets of equations and to solve for variables. It involves doing math.
Solving the unknown in software involves a similar working through. "Doing the math" for code involves executing code. It's faster and easier. Ignoring this is like restricting your bridge planning by avoiding CAD or doing the math by hand.
Yes, once a solution is mapped out the ideal would be a full rewrite. The benefit of software is that it can be modified and finalized directly like baking a sculpt or revising a manuscript.
If a button allowed the working schematic of your bridge to magically materialize, and changing the schematic affected the real world bridge instantly with negligible implementation cost then civil engineering would evolve in the direction of software development. It's not the other way around.
I've often wondered about this. Who exactly has to be licensed? Are there management layers in civil engineering firms where the license isn't required? I think my point is pretty easy to follow. I'd love for all of us to be licensed to practice software engineering, but I don't hold any hope that it would fix all of the other compounding problems that our industry has as it relates to product/project management and management-born issues.
For example, would being licensed stop executives at a triple-A video game company from prematurely announcing games / release dates, or accepting pre-orders for games that won't be finished on time, and forcing all of the people under then to scramble and crunch and do things that would generally be considered anti-thetical to whatever being licensed in software engineering could mean?
The reason you see so many autodidacts is that its one of the few engineering fields where tinkering is both cheap and safe. Civil engineers basically can't tinker beyond maybe building models or using physically realistic simulations, and neither of those is a substitute for really building things at scale. Anyone with a decent computer can tinker endlessly with software with little or no consequence to anyone else when it breaks.
The only other engineering field like this I can think of is electronics, where you also have a lot of autodidacts because components are cheap and unless you are messing with super high voltages it's pretty safe to play around.
There is always a huge pushback against licensing in this field because it would be (accurately I think) seen as a way for universities to erect a mandatory toll booth.
The second huge issue is that we don't have a good theory of good programming practice. There was an attempt to systematize things in the 90s "design patterns" era and all it got us was a ton of monstrous overengineering satirized by the many "hello world, enterprise edition" joke code bases on GitHub. More academic efforts around provable correctness have never managed to cross the practicality gap for widespread adoption.
At best it could be a license for specific safety critical applications but that would be dependent upon the licensed ones actually doing a better job at being safer which is harder for the first two reasons you listed.
Hell certifications are infamous for generally not being that career useful.
Uncle Bob argues that this is why we need to start self-policing and create certification structures that take this into account.
If we don't, the next software-related disaster will force governments to set up regulatory structures the only way they know how -- tied to university degrees. They won't understand the value of a self-taught developer.
We do. We should be the ones to create structures in which such people can be officially recognised for their abilities.
If a firm is found to have inappropriately (for example, pressuring a professional engineer to affix their seal inappropriately) they will lose their certificate of authorization and then not be able to do any engineering work.
E.g. the Iron Ring: https://en.wikipedia.org/wiki/Iron_Ring
> The Iron Ring is a ring worn by many Canadian-trained engineers, as a symbol and reminder of the obligations and ethics associated with their profession. The ring is presented to engineering graduates in a closed ceremony known as the Ritual of the Calling of an Engineer. The concept of the ritual and its Iron Rings originated from H. E. T. Haultain in 1922, with assistance from Rudyard Kipling, who crafted the ritual at Haultain's request.
> The ring symbolizes the pride which engineers have in their profession, while simultaneously reminding them of their humility. The ring serves as a reminder to the engineer and others of the engineer's obligation to live by a high standard of professional conduct.
I didn't see it mentioned in the Wikipedia article, but i was under the impression that the first of these rings were made from the iron of a bridge that failed.
There's a reason we have hard standards for being a PE or an MD. If you just let anyone do it you risk many problems.
Most software simply isn't like this. The valley loves talking about disruption and all and how world changing everything they do is, but the fact of the matter is social media isn't killing anyone like a failed bridge would or a person who isn't qualified as a doctor. Most of the money made in the valley is off of advertising or data. Who cares if the product is shitty? people don't die. rich people make a little less money.
A bridge hosts what? 400 people at worst (i.e. when there äre passenger trains on it.) Social media easily hosts 400 thousand or million people.
The single bridge-collapsing event is very dramatic and visceral, but digital platforms allow us to cause damage and death by a thousand cuts.
Work for compensation.
I never really thought about that. There is so much truth to it and why so much Saas is a never ending feature factory! I assume Basecamp thinks of their Saas as a project and that's how they are able to escape the never ending Big Ball of Mud software craziness.
The world would be a better place if developers (or the company they work for) were as much on the hook for bugs in software as en engineer is for a bug in a bridge. How programming can still be the wild west in 2020 is beyond me. I've read some good thoughts about this topic by Poul-Henning Kamp (Varnish, FreeBSD) but can't seem to find it at the moment.
I would recoil in disgust if I saw a civil engineer building a suspension bridge by hand as well.
I think your example points out exactly why some think software engineering is a joke: they rush ass first to implement something (and they implement the wrong thing) instead of sitting down and figuring out the actual requirements first like any real engineering job would have you do.
And it looks like everyone is pushing it more into this ass-first direction with agile. Let's not even try to plan ahead! You know what you want next week, so this short-sighted focus leads to chaotic development and once the real requirements are figured out 9 months into the project, well too bad it's too late to redesign and rewrite it all properly. So it's forever going to be a bumpy and crooked bridge on the verge of collapse, held together by more and more duck tape, hot glue and occult ceremony. And there's a plastic tunnel hanging underneath it. Only the brave will crawl through.
If it were so easy, then we would have done it already that way for the last seven decades. The simile topples over upon further contemplation:
• client is not a domain expert
• to an overwhelming part, client needs are easy to transport into the mind of c.eng.
• can employ a wealth of standard solutions refined over the course of milleniums
• client is a domain expert for the subject matter that the software is supposed to model
• to an overwhelming part, client needs are difficult to express and transport into the mind of s.auth.
• if a standard solution exists, the client would have already bought it off the shelf, so coming to a s.auth. always means customised development
• the entire sector is still in its proverbial baby shoes
We have to come to grips that we unfortunately can't apply what happens to work well for a different sector. The supposed value of non-traditional software methodology lies in that at least the client notices that the requirements are off the needs rather early.
So instead of pushing for more effort & skill for up-front planning and modelling of the requirements and design (and trying to employ modelling tools & formal methods), we're just like fuckit nah let's just implement something and see where that leads us.
It doesn't help that so many of the up-front design failures were not examples of engineers screwing up but sales people selling shit and then having engineers cook it.
We'll be stuck in baby shoes for a long time with this approach.
Often times, it's very easy to determine the functional requirements: "Process this billing statement", "Spit out that report." The complexity doesn't come from the requirements. It comes from the constraints: "We only use this ancient version of this database", "We didn't tell you at the start that the users expect to interface with this system via email".
To quote Mike Tyson, "everyone has a plan, until they get punched in the face." The point of Agile is to get punched in the face earlier and more frequently.
Those constraints sound like requirements: we require that only this ancient version of this database is used. We require that users can interface with this system via email. Different term, same thing.
That's in the bucket with the kind of stuff that I'm advocating people should pay more attention to up-front. Gathering these requirements before you start designing anything is a big deal. If you failed to do so, then you failed to do a proper job at the part I called sitting down and figuring out the actual requirements.
This is something that crops up quite frequently in my work. We'll get a requirement like this: "the app should use HTTP like a web browser, not a different protocol". On inquiry as to why it's so important for something that's not a web browser to so strongly resemble a browser, the answer will be something like, "so we don't have to ask IT to open a firewall port". The person deploying the software could just fill out the paperwork, but they find it easier to "require" that the software sneak past their own corporate security controls. This is the sort of requirement that is real in some sense and not in another sense, depending on whether you define the customer as whoever you're talking to on the phone right now or the business as a whole.
My company just shut down an entire office, they offered three out of four critical employees the opportunity to move to Atlanta. They didn’t want to move, opting to retire instead. Company just shrugged their shoulders rather than letting them work remote, gave them like a month to transfer knowledge and that’s that.
In software if you know what you are doing ahead of time you are not really innovating and you might as well be using an existing system. Since everything that is standardised you can just use as libraries.
When building bridges, you can't just use a library that's .buildBridge(...parameters), even though similar things have been done thousands of times before. With code, if something is done enough times that you know how to plan for it, it is likely already a library.
You can plan building a bridge since you have done that and have experience of it thousands times over.
"Everything was waterfall and then came agile" is myth, but yes, it looks like it's fashionable to no longer try to plan ahead. I'm not convinced the reasons are good, and I'm not convinced the craft of planning ahead was ever perfected to the point that anyone could say it doesn't work.
Scrum, XP, Agile all date back to the 90s when one server running PHP or Perl (with SQL injections) passed for software and others were still re-inventing basic data structures in C (and then gasp C++ with templates!) from first principles... The methodology, tooling, rigor, and collective experience in software development has taken leaps in the past two to three decades. Likewise, understanding systems and planning ahead has become so much easier. If only people took it seriously and spent as much effort on it as they spend on fad-of-the-year frameworks.
People just stopped trying, and when I look in software projects now, there's hardly ever anything resembling a model of the software that you could use to test new ideas "on paper" to see how they fit the given problem and current application.
People aren't even trying, just like they aren't even trying to achieve correctness: https://news.ycombinator.com/item?id=22224054
The less you try, the harder it will be.
> In software if you know what you are doing ahead of time you are not really innovating and you might as well be using an existing system.
I think the vast majority of software is boring and not even meant to be innovative and indeed would be best written using an existing system, but customizing these to the specific needs is just another can of worms. As with bridges, you can't just copy & paste an old bridge to a new location and use it as-it is, you need to design it given the locale and other constraints. It's still probably going to be yet another relatively boring bridge with no innovation.
And indeed a lot of software work is all about using existing systems, but perhaps at a lower level than you posited. Customizing complete off-the-self packages does happen, but it's more common to glue something "new" (but not innovative) using existing frameworks, libraries, services and glue languages.
You still need to design to do it right. But even here people seem to rush ass-first into whatever kit looks fashionable now.
The last time I vented on the subject, I had to dig out the research papers I keep on my desk, because there was more than passing curiosity. Oh yes. I keep these on my desk so I can quote them when needed.
Check out this research paper from your nearest sci-hub entry point:
- DOI: 10.1109/MC.2003.1204375 ; "Iterative and Incremental Development: A Brief History"
Yes, people don't do their jobs. That's not the fault of the process that they are failing to adhere to. Indeed, no process of any type could ever save them. It's the culture that is wrong.
So, in a roundabout way, I agree that Agile isn't the solution. No bottom-up process will ever succeed, because at the end of the day, the failure of the team is always the fault of the leader.
There are no "actual" requirements for most software projects. Software is generally co-evolved with the audience.
Bridge designers can work like they do because bridges are hard to change and fundamentally pretty similar. But because software infinitely changeable and infinitely copyable, our field is different. If you're going to build 500 highway overpass bridges, you'll need engineers looking at each one, because local conditions and needs vary. But in software if we need to serve 500 users, we build one product, give each user a copy, and just keep adding features to solve the local problems.
A big reason we think software can be like bridges is that in the early history of our profession, we were tackling problems that almost worked in a waterfall context. That's because we were taking existing paper processes and automating them. But the hard part of requirements discovery via process coevolution had been done for us by people tinkering with paper and human working relationships.
That era is past. Today if the requirements for something are perfectly knowable, that's because it's either trivial or it's copying an existing piece of software. Any real product is discovering what's possible. It's growing along with its users' needs. It's solving new problems created by other people and groups.
I know of no significant piece of software that, like a bridge, hit 1.0 and just stayed there for a decade while getting plenty of use because the requirements were perfectly foreseen. Not one. To me that's a sign that perfect foreknowledge is, if not impossible, at least incredibly rare. So I think the thing to do is to figure out how to build excellent software with the expectation that needs will change.
As an example, the IRS is still running 60-year-old code: https://www.nextgov.com/it-modernization/2018/04/irs-60-year...
Is that because that code and hardware is especially good? Because the initial design and research process was so perfect that people are still entirely happy with it? I'm guessing not.
The process is nothing surprising. Write tests, document your code, follow the style guide, etc.
Because it's not about bridges or tunnels, common sense is thrown out of the window, people start building something they conjure out of thin air.
Few people say 'No!', we don't do anything. Anything. Until we have written a clear business case / usecase, a raison d'être for this project.
Agile is often abused to not think, not design and just follow the whims of the customer. Nice for billable hours, but long term?
Do you produce anything of value?
And even when you do have a solid market-fit figured out, you still don't know what your customers will actually want. (And don't get me started on customer research. People lie all the time, and their accuracy on what features are honest-to-$deity blockers.. Nope.) This means that for most parts the incentives are misaligned and work actively against delivering high-quality software.
Underlying the agile manifesto is the need for engineering to be properly aligned with business incentives. Continuous delivery, fast iteration cycles, incremental improvements and rapid deployments are all facets of the same fact: you don't actually know what your customers want (because your customers don't know what they want!), and the only true way to figure it out is to iterate as fast as you can.
It's only when you have an established moat and a practically guaranteed, net-profitable income stream, when you can even imagine at having the opportunity of doing things the way you would assume you want to.
Oddly enough.. the companies who have such moats and guaranteed profits tend to be the same ones that have been the slowest to modernise themselves. Banks - until the modern online-only challengers came along. Insurance, where the regulatory moats are even higher and is only now being "disrupted". Loan brokering. Energy. Water. Public transport (where monopolies and/or charters prevent competition). Healthcare. On and on and on...
And even then, every one of these established, guaranteed-profit machines has the same problems: the moment one good new player enters the field and starts stealing customers, the old guard needs to find a way to either adapt - which is the best-case scenario - or rely on their power structures with politicians and quickly require new regulations to strangle the usurpers.
Software is expensive to make. It's only cheap to deliver. And time spent making the wrong thing is really expensive.
EDIT: I forgot to say this the first time around. Engineering career incentives are also misaligned. Maintenance is not appreciated, only shipping new stuff is. So the developers who would want to improve what exists and make it better will be looked down upon. The promotions and raises go to those who ship something new, even if it ends up setting the world on fire a year later.
If you don’t even ask the users, it’s even worse.
But that’s okay. It is simply not possible to accurately judge how something will work until you get to use it. That goes for the creators, too. That’s why we iterate.
I do agree there are a lot of bad practices in SE as well, but let's not blame everything on them.
It's like sales people together with the customer decided the shape and colour of the bridge, as well as the number of pillars it has, and how many lanes it has, and what material it's made of -- here's the stack of things you build with -- and what other fancy features it has, and now finally we can call the engineer so they can hop on a bulldozer and start engineering with their hammer for the next two weeks and show the result so we can adjust the shape if it's not as pretty as we imagined. Actual engineering didn't happen.
Features (or epics or whatever) are larger and contain multiple user stories. In most cases features extend over multiple sprints.
It's totally possible. The only thing is that when the cost estimation arrives to the hands of decision makers, they open their eyes wide and decide that for that money they better go ahead with a bridge.
So IMHO it's just a matter of cost. Say you go with a bridge but there are some initial wooden stairs, and sometime along the middle of placing them they decide it is acceptable to pay the cost of stopping and replacing them with metallic ones. Could happen.
Biggest change I experienced in the rate of unexpected last-time feature changes in software, was having a project manager that first of all knew how to say "No" (or discuss the sense of the requests), and secondly, was able to communicate the real cost that each change would have (in terms of developer time, which at the end of the day means money). Then it would be the company's boss himself who would decide to discard the most crazy changes that were "mandatory" and coming from the sales people.
Turns out that every field of engineering is hard!
Even the language and best practise change constantly. Looking at possibly the most stable language C, we have entirely different best practise pattern from community to community.
New stuff shows up, but that doesn't mean you are compelled to leap upon it.
Or where it should be exactly: "It should be easy to move once it is build, right?"
Or what type of vehicles it should handle: "Just build a generic bridge. How difficult can it be."
But the time and monetary budget was already negotiated and written in stone: "Oh btw, you got 2 weeks and $537.25 to finish the bridge."
In a large corporation, the software engineer expects to be told that there are going to be cars on this bridge, and they are moving at a certain speed from one side to the other and that they will be of a weight between x and y, etc...
Understanding the domain goes a long way to get software done.
It's not that software engineering is a joke it's that you don't understand the difference between computer work and moving earth/pouring ckncrete. Of course people are going to plan the project differently in civil engineering. The consequences to building any part of a bridge wrong are pretty dire and redoing work costs much more than it did initially.
Maybe don't try to draw parallels with other forms of engineering just because it has the same name in university. The practical differences are large.
The PE exam is only needed for a handful of disciplines, like civil and HVAC engineering. Even then, you only need the PE certification if you are going to be signing legal documents. You can be a civil engineer without a PE working in a team producing designs and plans that are signed by a single certified PE.
By your logic almost no one that graduated from an engineering discipline would ever be able to call themselves engineer.
You can’t compare against paralegals/lawyers because calling yourself a “lawyer” has legal implications, as in, you must be certified by the bar or you can get in trouble. It doesn’t matter which legal discipline you practice, you must be certified by the bar.
For engineers no such thing as a bar association exists for ALL disciplines. The PE certification only covers a handful of engineering disciplines therefore it can’t be a gatekeeper for all engineers. Moreover, note that certified engineers are called Professional Engineers, not just Engineers! Even the name distinguishes between certified/non-certified, it doesn’t try to take over every meaning of Engineer.
I think that the engineering mindset (adherence to the scientific method, evidence based decisions, planning for the future etc..) is one that is definitely shared by both groups at least.
But you can absolutely get away with building software without proper engineering standards. It's not so easy to build bridges that way.
I'd wager that it is but the stakes for failure are too high to wing it (hopefully).
We want to build a bridge that spans N meters. We don't know how to do it but we can go look at an existing bridge and copy it. We might not understand metallurgy / physics that well, but we talk to suppliers and ask for "steel of this shape and size". Ditto cables, concrete and everything else.
Probably, provided we're not scaling up or changing the design too much, it would work just fine.
When software goes wrong, the effects are more often than not, intangible. When mechanical engineering or electrical engineering goes wrong, people can die.
Software can obviously kill people too, it just happens less. Then industry practices revert to the mean due to cost cutting.
I’ve always thought it is a little bit of a stretch.
It's essentially applied physics.
Software is more like nailing things together in the hope they might work. ML has some modelling, and formal methods are available for mission critical projects.
But the rest is mostly nail guns and glue.
Engineers have never done themselves any favours with the "engineering" label. In many countries, especially English-speaking ones, the job doesn't get the respect it deserves.
Most people have no idea what the job involves. They literally think it means someone with an oily rag who fixes cars and/or computers and/or drives big machines around to make bridges and tunnels and such - like a house builder, but on a bigger scale.
* Mathematics isn't only about calculation and applied physics. When you write a simple algorithm and convince yourself with a logical argument about its correctness, time complexity, etc. that is math too. You also do calculations when you design various systems (latency, throughput, etc.)
* I know a dozen mechanical, structural, and electrical engineers. They almost never model anything from first mathematical principles, they use well known tools and methods they learned. Their "nail guns and glue". Actually I think most of them don't understand math/physics behind it very deeply. So even if those methods are underpinned with mathematics and physics, it's abstracted away most of the time which is good for practical purposes.
Even in "user-interface programming", I often had to use math, algorithms, etc. In other parts of software engineering I used it much more.
Depending who I talk to, I use "programmer" or "software engineer" most often.
I'd use "software engineer" if I could in good conscience, but "software developer" is pretty neutral while still being accurate.
It tends to make more sense for me. A book that starts out as a romance is just as hard to convert to a spy thriller half way through as a bridge and a tunnel (Ok not total effort but in terms of percentage of rework)
As so, I'd consider software development can qualify as engineering. If you're taking the work of computer scientists and mathematicians (or any other science fields) and applying it to software, it fits the definition. If you're just laying code to a given spec without much more thought, then you're just a programmer/developer...
There's not really the class divide in engineering fields that you're suggesting. I have a brother who is an ME, designs power plants (the building sized ones) and is not "professional".
I asked him about it and he said it wouldn't change his role or his salary, so he never bothered going through the process. IIRC there's one person on the team who is, for whatever formalities are required.
Is that person making more money? Because I've heard stories that these people do, because they are especially valuable to the company.