I apologize, I am currently too busy to give you a proper reply. The gist would be that the link you give is by an author that is not being sincere at all, and only seeking to limit damage. And the furries/'deviants' frequently prioritize themselves over others or things overall, which is especially bad reg. the Linux kernel, since the kernel among many other things is used in many safety-critical and life-critical applications and thus peoples' lives directly depend on the kernel not being crap or unreliable. And "going too far" sounds like they don't mind the end result, just the speed of change and the current approach of getting there.

Well, to be fair, might there have been debug symbols and the like in the binary? I also believe there typically are various compiler flags that can be used to decrease the size of the produced binary.

Sorry, I will give a proper reply in a few days, it has been fairly busy for me these days.

Isn't logic, at least as a discipline, considered a branch of mathematics?

And in which regard is it a fallacy? For instance, if some comment astroturfs some product somewhere inappropriate, and gets many more downvotes than upvotes, isn't it correct to say that at least in this case the comment got less visibility and thus at least one of the purposes of the downvotes was fulfilled?

By "logic", do you mean "wisdom", "sense" or "insight"? Possibly the issue being manipulation of people? Or whether a reddit-like that supports downvotes is fundamentally unsustainable and/or too fragile and vulnerable?

Hmmm... are you using two possible states instead of three possible states? Why not have the following possible states:

Up
Neither
Down

instead of

Up
Down

?

Of course, I might misunderstand you.

Also, this modelling excludes having both up and down, which I think is correct for our case.

we need

we

Giving others warning of the available or intended actions is not necessarily a bad thing. It is right that bluffing is generally crap. But if you can and will do things in practice, warning in advance is not necessarily a bad thing.

That reminds of an approach I have used a few times: The setting is that you have a problem which can be solved by a new component you would create, but you suspect or know that at least for naive implementations, its performance will not be good enough. And it would be useful to have some implementation of the component that works soon and that can be used in the rest of the system.

The approach is that you then create an interface which you seek to design in such a way that it allows for later implementations that are sufficiently fast for your current or maybe future needs. You then quickly implement a naive solution that is correct and can be used elsewhere. If or when it turns out that you do need greater performance, you then implement the faster solution, and if the interface does not need to be changed, switching between or comparing different implementations might then be easy and quick.

I see, that is an excellent point.

I do think it is wrong to experiment just for one's own learning and generally costing the company both time, money and resources as well as giving the company long-term problems, but that is not what you are writing about. I think however that such a fear of being seen as someone that experiments against the company may help justify the fear, laziness and constant firefighting that you describe (from what I understand from your comment).

I wonder what a good approach to this might be. Document and explain the worst issue that would give the greatest benefit if solved and with a fairly low risk, present it to decision makers and others, and if a go-ahead is given, succeed with the project and document the benefits? And thus build up trust and show the merit of this approach?

One question is how to ensure that benign experimentation and boldness happens without malign experimentation happening. Maybe explain this challenge to decision makers? Though that may also touch on internal politics, cunning and the like.

Could you explain further?

This very word "Value" as in "Business Value" is the primary cause why you now need 10 more people to do the exact same thing as developers could single handed 5 years ago.

Is that really the case?

I did also find it a bit curious that Java was used for mobile platforms, but as I recall, Java was originally meant to run on certain kinds of embedded platforms, with its main feature being cross-platform. There was (might still be) something like Java ME, though I would believe it is scarcely used these days. The main "editions" of the Java "platform" ended up, I believe, too bloated for many purposes, including containers - the idea of running multiple applications on the same JVM and thus "amortizing" (I think the CS-term is) or decreasing the overhead of the JVM per application did not have enough isolation and was also a very Java-specific solution which does not play well with generic containers and the like. I believe that is why they have sought to "modularize" the JVM itself, primarily for the purpose of making it more suitable for usage with containers through less overhead per JVM instance, and I believe that is why it does not seem to be a solution that is encouraged for any libraries or applications in the ecosystem (though I could be wrong about it not being encouraged).

I do very much like the cross-platform aspect of it, especially the cross-platform concurrency support - Java was one of the first mainstream languages/platforms to get an official memory model, and C++ as well as .NET only got it several years later I believe. There are other and in multiple important regards better ways of approaching some of the challenges that one might encounter reg. concurrency and related aspects, such as shared-nothing concurrency as well as the way that Erlang approached both concurrency and distributed systems, but those did for various reasons not hit the mainstream as much (I have heard that the Erlang VM/runtime is not as efficient as the JVM reg. speed, for instance due to JIT and other runtime optimizations as well as Java being statically typed, though it might be better reg. memory usage and other aspects - I do not know).

Java the language has gotten much better with Java 8, though is still very warty. There are other languages - I like Scala myself, but cannot unconditionally recommend it: often breaking backwards compatibility; compilation times (though the code can also be shorter); poor tooling (not that the tool authors did not work hard and well on it, more that the language is both complex (its core is actually small, but a lot is built upon that core, and the academic influence can result in half-baked and experimental parts being included) AND has kept changing a lot); abuse, harrassment and hostile take-overs by SJWs or (((people))) of major libraries and the like, counts against it. But it does have some very nice things, and the Java language designers look a lot at Scala when figuring how to evolve Java the language, especially the ML and functional programming features and how Scala encodes/implements them on the JVM and its approaches and abstractions reg. it. They do seem to seek to learn from the mistakes and experiences of Scala, and they have the advantage of controlling the platform and being able to change it.

Since when is the usage of archive sites controversial? I thought it was a common operating procedure for newspaper websites, including on /r/the_donald and I recall on /pol/.

I mean, there's even a bot posting an archive link here in this thread, see derram's comment.

But turning off Javascript is admittedly not a bad idea.

Would have liked it if the link was an archive, like archive.org or archive.is, such as not to give ad revenue for clicking.

I can see your argument somewhat for some applications, though there are some parts of an application that do not change across platforms, typically business logic. And having those duplicated is typically (very) problematic, at least for business logic. Though, depending on the type of application as well as the architecture, if you have most or almost all of the business logic server-side, that is less of or not an issue. Whether such a solution or similar makes sense tends to depend on the domain as well as goals and requirements of the project.

Then there is the issue of cross-platform all the way. And I think you have some very good points. But, I would also say that it depends on the priorities and the target quality. If mediocre or crap is OK, then doing a different solution might be too expensive (though, in some cases such solutions might be problematic in some regards, requirements and priorities might change, and such a solution might not be future-safe - building and planning it in such a way that you can throw the crappy parts away or similar plans might be a good idea). I do believe there are some cross-platform applications written in cross-platform languages and tools that do very well and have good quality for what they do, though it definitely does not always happen or is viable for all projects.

That said, I would say that C can be written in a fully cross-platform way for most kinds of applications, though this may also depend on the definition of cross-platform being used - cross-platform all the way, just the server-side, or other.

Any good alternatives in your opinion, especially if you want something that has good cross-platform concurrency support?

Java the language, Java the JVM, or Java the ecosystem?

Sorry about the URL lengthener, Voat currently does not accept tilde ("~") in submission URLs.

Link.

What good alternatives are there to Android? iOS and Windows Mobile do not seem much better, though I could be wrong.

If that is indeed the cause, that does make me worried about the future of Azure - reliability is really important for such services for it is a major part of paying for them and investing internally in their usage. I think it will be a very good idea for those using cloud services to seek vendor independence as much as possible and ensure they have the option of switching, but how viable being able to switch is in practice as things are currently I have no idea about.

It also reminds me of this story: http://blog.tdwright.co.uk/2018/09/06/beware-runonstartup-in-azure-functions-a-serverless-horror-story/ . I read on proggit that AWS and GC has better spending controls than Azure, such as billing limits and notifications.

In case you want to be somewhat focused on development, ensuring that you have a good foundation might be useful. You seem to have a bit of industry experience, so maybe something SICP might be useful, though I haven't read and worked through it myself. Then again, it might not.

There is also DevOps, though I have very little experience in that regard. If you like both development and operations, maybe that might be a good direction.

What would the creators or owners get in return for any troubles on their part? Botnet creators don't care about that aspect, and they likely often get away with it.

That is definitely true. If you have the opportunity to find the time, it might make sense to study and play around with technologies and/or other in your free time, if you aren't already. I personally have played a little bit around with both career-relevant stuff as well played a little bit around with game development using Godot: https://godotengine.org/ . Just for hobby development, mind you, game development is definitely not my main goal reg. careers, too many developers that want to do it as well as other aspects.

RMS has written against "intellectual property" as a concept (though I haven't read it lately), and he pretty much invented "copyleft" as we understand it today.

Richard Stallman has definitely had a very large influence on FOSS and the like, for better or for worse, but he was definitely not the only person in the beginning of those thoughts, ideas and movements.

But funding research isn't what Certhas argued: [...]

I don't believe that is true, at least reg. with the specific universities as well as research in general getting something in return, I think that was definitely part of his arguments.

[...] he argued that some tools are too dangerous to be allowed commercial use, which in the end doesn't make sense, because if the tool is known about, and useful enough, it can be replicated. [...]

I think he argued much more broadly than that, and even the point reg. limiting access does make sense. It is a good point you have reg. replication and the possibility, but in some regards, even hindering some or slowing them down can make a large or extreme difference. And it also limits who has the possibility of even pursuing replicating it or other approaches.

[...] And anyway, not everybody cares about their legal licensing regime, least of all people whom he wouldn't trust with a piece of software he'd write. [...]

Very true point, and he and others definitely need to keep that in mind if they aren't already, and it is very wrong and irresponsible of them if they aren't - but it can definitely still be a considerable hindrance in certain other case. And in some of those cases, those extra hindrances can be sufficient or good enough. But yeah, very true point. For some cases, software can then be kept private, not even giving out any binaries, and Richard Stallman and others do in their writings allow (somewhat) for that. One exception is I believe that of server software, which I believe Richard Stallman has argued should also be open.

Reg. working for "the man", you do get paid a salary, right? And do others benefit from the work you do? And is the company moral or at least not overall evil?

Good points. I think a lot of companies gain more than they lose from copyleft, and a number of companies use copyleft in various ways. For instance, some companies offer both copyleft and proprietary licenses of their products. But copyleft definitely introduces a number of considerable problems.

Yeah, it is Certhas' comment I meant to link to. I believed it would render well, but didn't check.

This is the way communists use the term "exploitation" to refer to voluntary trade.

Aren't he arguing for the universities getting something in return? For instance let companies buy the rights to the source code if they want?

Also, it seems like a different meaning than the one used by communists; they tend to present working for others as "unjust", while the meaning here seems more neutral, at least to me.

A non-commercial license prohibits this. Some of the replies feel the contradiction, but they don't really put their finger on it.

Is he generally against copyleft? Copyleft can IMO make a lot of sense, but it can also have drawbacks from an overall perspective, heavily dependent on the specific case in my beliefs.

Anyway, RMS's view against "intellectual property" neatly sidesteps the idea of responsibility for tools being misused by treating knowledge differently from physical objects, which it is.

Eh... I must say that he makes some very good arguments in the start against that.

Were you brutally honest about your qualifications and experience as well as lack of experience in different regards at the job interview? If so, it is alright, they chose to hire you and knew who they were hiring, just focus on improving and doing a good and responsible job. In my opinion, it is OK to say that you don't know a given topic, but you can learn about it if necessary, maybe in your free time - though that does depend on country, culture and company. If you weren't honest... well, I do not believe in "faking it until you make it", but it is your life and your responsibility, and things can be very complex. But still.

Reg. learning, I would recommend the other books mentioned in this thread, as well as Bjarne Stroustrup's http://www.stroustrup.com/programming.html , it is not just about the language but also about professional programming. Apart from that, build things in your own time, read code and topics online, and read forums like this and /r/programming - I know, reddit, but it still has value, at least for now.

But you should be aware that C++ is one of the harder, older and cruftier languages and are sometimes used in fairly challenging domains (though not always). Given that you want to work with C++, I guess you want to become a hardcore developer and/or work in embedded or HPC or similar (or game engines?). C++ is also somewhat weird - ensure that you learn at least two other somewhat different languages.

It's funny - Scala has a library called Scalaz. Some developers (SJWs or I recall (((people))) ) didn't like the abrasive, and direct tone of its main author on forums and his stance on free speech and being against "codes of conduct", so they harrassed him, kicked him out, succeeded in wrestling control of the project from him for a time, and after they lost control of it again, they copied the project and called it Cats with minor variations - and kept harrassing the guy, including at his work, foe a long time after.

Sorry about the archive, Voat does not seem to support "+" in link submissions.

I found the discussion on generics/parametric polymorphism especially interesting.

Reg. when software is ready, one also has to consider deadlines. In such a case, I would believe that it typically for most cases is a good idea to inform the relevant decision makers that are responsible for the given project or product whether you believe the goals can be reached, ask them how to prioritize, ensure that there are proper fallbacks if the deadline fails, and generally keep them well-informed such that they can take decisions. That does, as you say, depend on the case.

In any case, I strongly agree with you that prioritizing the company and keeping focus on how one can help the company achieve its goals are very important. And here I must apologize, for I believed the blog post cared more about how developers can do a better job, instead it indeed seems to "sell" things to developers, and I think that is similar to a lot of SCRUM marketing, because they tend to focus on how developers can be "empowered" (whether true, false or the opposite...) instead of focusing on how developers can better help the company, which ought to be the focus.

Yeah. One thing that I fear is that various people care more about being able to say that they are doing Agile/SCRUM because it is seen as the proper way of doing things, there is pressure from others to use it (especially if there were problems with their previous way of doing things), or being able to write it in their CV; than caring about it actually helping or being a good approach for the problems they face. I believe that there are some cases where (modified Agile/SCRUM) is good or great (in part because the methodologies tend to take credit for old techniques and methods that existed before these methodologies...), but you have to continuously evaluate whether it works well in the long run and do predictions and root cause analysis, and you absolutely MUST adapt and change it (a lot if necessary) to fit your case.

At the end of the day, employees are hired and paid to help the company succeed, and preferably succeed a lot or more, and thus that is the basic goal for a professional developer. And that is why it makes me extremely suspicious when some of the SCRUM consultants and similar talks about the advantages for developers, about how it "empowers you", instead of how it would help the developers and others do a better job. And I don't even recall any arguments where numbers and cases that shows how developers would perform better or the products or services were improved over time with more functionality over time than expected and better defect rate, etc. The marketing is extremely off.

It sounds like you/they are front-end devs. I do not work in that field, but if I was, I would seek to learn the core and most successful theories and ground concepts as much as possible, though that is easier written than done. It seems like a fairly active field, and if it is like distributed and concurrent programming, even the fundamental thoughts, ideas and approaches are (still) evolving, changing and developing. That way, it might be more feasible to generalize and re-use what one learns. The learning of the specific APIs are typically much less reusable and long-term useful. So, if possible, sticking to a few frameworks and technologies, switching/updating every few years, be productive in them and earn your salary, and learn the most successful concepts and theories seem like one way that might be OK. And also go after what interests you and what fits your skillsets, talents and plans.

I recall from the blog post that the changes were somewhat small. That said, I think you have a very good point reg. frequent changes. It is something that has also affected the Scala community negatively (though the changes are not nearly as frequent/large for Scala as for TypeScript, I believe). I believe it is however something of a trade-off - if you do not have frequent changes, then it can become much harder to evolve and develop the language. I wonder if TypeScript will slow down its evolution. I guess it won't slow down a lot if it slows down, for the rest of the browser front-end environment tends to change rapidly, and will likely continue to do so for at least some years to come.

The frequent changes likely hurts (much) more the larger and/or numerous your code bases are in TypeScript.

Spam and likely trolling directed at me that does not contribute.

Irrelevant to the topic, and more spam.

Part of the reason I was curious is because I do not fully agree with you regarding there not having been considerable changes at the fundamental level. I would definitely agree that there is a lot of churn regarding new frameworks, especially in front-end development, but there are some areas where things have changed very much, and where these changes makes large differences. Especially in regards to concurrency. Of course, the best option regarding concurrency is to avoid it as much as is viable, but for those applications where the difficulty includes for instance scaling in regards to massive amounts of concurrent activity, the newer developments very much can help or be necessary. I don't think Twitter, for instance, would have been nearly as robust and resilient regarding scaling of concurrent activity if they did not approach the challenges with fundamentally different/newer concurrency (and arguably distributed) programming models. They used to have lots of "fail whales" back when they still used Ruby on Rails, but that is a very rare sight these days.

Of course, what is very important to remember, and which I think you have a major point regarding and which I touched lightly on previously, is that these techniques are far from always needed and can be much worse than simpler alternatives due to their costs, and so they should generally not be used unless their many costs justify their usage (though their costs can very a lot from team to team, project to project, organization to organization, etc.). And thinking through things can help very much - if for instance building a very large "monolith" for a given project will be very risky, time-consuming, difficult to maintain and might need a lot of (lucky and successful) design, requirements work, etc., it will typically be much, much better when possible to instead create a lot of smaller, independent applications, especially if these applications do not need to communicate with each other.

But my argument is overall that, for some applications and challenges, things have changed.

I also think that (meta-language/ML-style) functional programming offers a lot of improvements for many/most cases and areas for basic development, and I think that is a major part of why such functionality has seeped into all mainstream programming languages, including Java and C++. But I do think that a focus on choosing the most suited fundamental approach and avoiding "complex"/"advanced" solutions and approaches when such are not justified gives much more value, and that another part of the main value of functional programming is that it supports such "complex"/"advanced" solutions and approaches when such really are justified or even needed.

Concurrency in particular can be very, very difficult to do correctly depending on the task or project. And while the first approach to concurrency should always be "how can we avoid concurrency or avoid having to deal with it", it is for some projects and tasks necessary to deal with.

Out of curiosity: Which kind of applications and software do you work with? Front-end? Desktop applications? Mobile? Fullstack? It does not sound like embedded or back-end, though I could be wrong.

Good point, though I would have liked it if they had clarified if they only used search engines or if they also used some other ways to factor in the number of skilled engineers world-wide.

But Tiobe says in the page you link:

Popular search engines such as Google, Bing, Yahoo!, Wikipedia, Amazon, YouTube and Baidu are used to calculate the ratings.

As far as I know, the Tiobe ranking is based on search engine term popularity. The Redmonk ranking has a somewhat different way of ranking, based on both GitHub projects and StackOverflow ranking, which seems a little bit more reliable (though might favour projects that tend to reside on GitHub and penalize projects that tend not to be hosted on GitHub or not being hosted publicly - which might well be the case for many/most embedded projects, which I would assume includes many C projects).

I could imagine that there are not many new projects started in C, outside of embedded programming at least, and that it was mostly just maintenance that happened in C. I once heard that C++ for some period at least had an increasing share of embedded programming, though C still has the advantage of being much, much, much easier to create compilers for than for C++ (I do not know if LLVM changes that to some degree given its architecture, in regards to embedded).

Java 9 API. It seems like they combined the Javadoc APIs for Java SE and JavaFX into one, and have JavaFX as a separate module. The new search box in the Javadoc API view is nice (try for instance to type in Set, or of(). There are new factory methods for collections, for instance, the collection method for Set is of (link).

New features.

I think it is most useful for projects where only a little of the C++ has to be tailored or changed to accommodate the C++-to-Javascript compiler, as well as a clean separation between the C++ that would have to be changed and the C++ that would not. This page mentions games as one area of use.

GitHub repository: https://github.com/eclipse/openj9.

FAQ: https://www.eclipse.org/openj9/oj9_faq.html.