Can you elaborate on the upward trend? You mean like going to Senior, Principal, etc.? I feel like saying yes to everything ultimately just moves you to the business side / customer side, which eventually leads to budgetary control over a larger group.
Ultimately in my experience titles mean nothing, right now officially I'm just "software engineer", you can be a CTO in a 2 man company, which is cool I guess but it really doesn't mean much.
What I mean with upward trend is that I can negotiate conditions like benefits (remote, insurance etc... ) and a better salary, etc..
I never understood why larger companies do this, I.e. either early stage of your career or as a contractor (with some possibility to FTE) and not as directly to FTE if you're a generalist. Companies do at-will employment, but I guess it is difficult to let go without evidence (I.e. performance reviews) though I'm not really sure.
When some of the contractors went FTE at a previous role, their salaries dropped dramatically (though they were paying for their own health insurance through an agency).
Can someone elaborate on the programmer's perspective? I understood the first and second paragraph (super helpful thanks!) but the exploratory, reloading repl escaped me.
REPL (Read-Eval-Print Loop) is an interactive way to program. You feed bits of the program line by line, in contrast to compiling a bunch of files. This is kinda like giving instructions live vs writing down a list beforehand.
When solving some problems, it's easier and quicker to use a REPL to get something that more or less works, and then to copy the working bits over to a proper source file to reuse. Before this React Sketch, Sketch.app was just the equivalent of the REPL, where you'd only store the result of your work, and not the process. Now you have a way to, as soon as you're happy with a design you drew by hand, write the code to generate it in order to reuse it in the future.
let's take a concrete example. say you want to write a ruby program to scrape some information off a website (e.g. crawl imdb and get a list of the top 100 movies and their stars). so, how would you go about it?
well, first of all you want to download a page. you haven't done in a while, so you google up the relevant ruby library (open-uri) and install it. then you load it up in a repl, like so
then just to confirm it, you go back to your repl, load your file and try
irb> page = get_movie_html('tt0093779')
you have now not only written the first part of your program, but it is available for you to use in your repl as you figure out the other bits. as you get each part working properly, extract it into a function and add it to your source code, then reload the source in your repl and continue working.
the main idea is you get very fast feedback about the specific bit of the program you are working on; the repl maintains the state of the data for you, so you can probe at it till you have ironed out the issues, and then once it is in its final form you add it to your concrete code and use it as a building block in the repl.
the analogy with sketch and react is that similarly, you can design a component (say a top navigation bar) in sketch with a very fast feedback loop, and once you are satisfied with it, you reproduce it in react and then reload your sketch environment from the react file, so that from now on the navigation bar you see in sketch is the exact one you have built in code, and you can use it as a building block for the next part of the site.
As an aside, does anyone have a list of tools that are in this category of "One more tool for managers and non-tech product owners, to sell them idea \"any cool app can be made just by few clicks of mouse, your dreams will come true\"". What's a good place to find such tools?
Even if you are trolling, good example of such products: PHPMaker. I hate it wholeheartedly as a programmer, but if you like tools like this - you will be satisfied :)
Yeah I didn't get it until I read this. I've read a few papers before and some of them have been too abstract / unfamiliar for me to understand. I've had to read them slowly 3-4 times just to get it to 'click'. I think it takes practice to read papers, but once you have the habit, maybe you won't be able to stop.
After reading a paper, you might want to try getting a pen and paper then recall by writing what have you understood as if you are teaching to it others. If you can't recall what you've read then reread the paper to fill in the gap and test your understanding again. This method is called Feynman Technique.
Well...I somewhat cheat here. I ignore papers without any code or coded examples. I don't have the time or patience to implement something just from raw equations.
What I worry about is how can we define accountability. At least you could sue a person if you got into a car accident and got injured (happened to several people I know). Suing a huge corporation and getting bullied around, settling for less, etc. sounds possible, but can happen too with people vs people. How do you even make a case when you likely don't understand what actually happened or could even prove what happened (crypto, copyright laws)? I'm all for reducing risk, but machines will make mistakes and I don't know what happens next.
History seems to have shown the opposite, in transport.
Trains are engineered to absurdly high safety standards and every time there is a crash, it's widely publicized and an in-depth investigation is required along with suggestions for systemic changes to prevent repeat events, and the companies are required to pay large settlements:
At the same time, trains are vastly safer than personal cars. Yet when a driver kills someone, police can barely be bothered to attend the scene and rush to excuse the driver and let traffic flow again.
The safety standards on vehicles are such that billions are spent on engine development yet we tell people to watch out for the "blind spot" in that trucks mirror contraption. We're soon going to have autonomous driving AI yet trucks are roaming city streets that are unsafe by design and regularly claiming lifes. I don't see Volvo and MAN settling with anyone over that.
I worry this is a case of micro vs macro environments. In a macro environment, it would be of interest to the general public to not determine why 1000 people died in a train crash. It's worth an exhaustive multi-year study and the victims' families can join a class action lawsuit and be tried as a single case. It's also in the best interest for all parties to find out why that crash happened in such a controlled environment to improve the service (private use of railways, well-understood environments).
In car crashes, each case could be different and difficult to figure out what was the exact cause. Cars are becoming more complicated, as with farm equipment vs farmers or the "check engine light". Without transparency into the internals, I wouldn't know what broke or was it my fault or the car and I would probably have to rely on the honesty of the company to tell me or my family that.
That's the point. For their base (and empirical) level of risk, there are huge binders of safety regulations for trains. Yet cars, which pose a vastly higher risk, are basically unregulated and safety is commonly ignored for what are peripheral concerns.
I think in order for you to 'sue' someone - they have to be negligent.
For the same reason generally passengers don't sue airline companies when something goes wrong.
There is an unbelievable amount of energy and money that goes into safety ... so much so that flying would probably be 1/4 the cost if they simply didn't care that much about it, and so there's a degree of 'public goodwill' in the whole thing.
I think the 'moral' issues will come down to scenarios wherein the computer has to make a decision like: do I swerve and kill my 2 passengers, or hit the car in front of me head-on and kill it's 2 passengers: pick one of two outcomes. I think this is the moral dilemma that is already coming up.
The way I understood the proof of work system is that it's there to determine which block is accepted as truth. So during a conflict, the first to solve the proof of work puzzle has their block accepted.
For distributed databases, when there are multiple conflicting transactions that touch the same data, I could see the proof of work as a method to determine which transactions win, especially in a global, multi-master model. When the proof of work puzzle is solved during conflicts, the transaction is accepted as truth and moves to a COMMITTED state. It seems kind of wasteful if you are paying for resources to solve challenges, but maybe there's a better way to decide who wins for trusted vs untrusted environments.
As an aside, Spanner I think acquires locks globally before writing. Maybe there's an interesting global-lock free model that just works using block chain, even if it's just for trusted parties (I.e. Google-internal).
You can have multiple winners at the same time. Proof of work doesn't solve the problem of conflicts. Everyone still has to pick which fork to follow, and you can't really consider something committed until it's buried under multiple blocks that you're confident the majority agree on.
maybe the ploy should be to get to V3 as quickly as possible as this pyramid / growth rate collapses or cut costs in V2 (cheaper servers, more efficient code - if possible). This is an interesting thought to me nonetheless.
