Skip to main content

Suche

Beiträge die mit Software getaggt sind


 
Yet another great article on software engineering and user experience design courtesy of Netflix. #programming #engineering #software

 
Qualtrics: SAP kauft für 8 Milliarden US-Dollar zu #SAP #CRM #ERP #Software #Startup #Unternehmenssoftware #Applikationen #Wirtschaft

 
Qualtrics: SAP kauft Software-Pionier für acht Milliarden Dollar - SPIEGEL ONLINE - Wirtschaft
http://www.spiegel.de/wirtschaft/unternehmen/sap-kauft-software-pionier-qualtrics-fuer-acht-milliarden-dollar-a-1237905.html#ref=rss
#IT-Branche #Software #Softwareunternehmen #SAP #Wirtschaft #Unternehmen&Märkte

 
Ich lach mich kaputt... bei der Erstellung des #Elster Zertifikat soll man ein #Passwort mit der Stärke von 20 Zeichen verwenden... speichert die das dann wenigstens noch in Klartext ab ???

#Finanzamt #Software #undso

 

FSF marks commons clause as non-free, recommends users fork software using it


We recently published a number of updates to our licensing materials. While we generally post individual announcements for these types of important changes, there were so many in such a short span…
Article word count: 618

HN Discussion: https://news.ycombinator.com/item?id=18423414
Posted by DannyBee (karma: 20136)
Post stats: Points: 141 - Comments: 20 - 2018-11-10T20:47:17Z

\#HackerNews #clause #commons #fork #fsf #marks #non-free #recommends #software #users #using
Article content:

We recently published a number of updates to our licensing materials. While we generally post individual announcements for these types of important changes, there were so many in such a short span that we needed to combine them all in one place. We recently added two licenses to our list of [1]Various Licenses and Comments about Them, updated our article on [2]License Compatibility and Relicensing, and added a new entry to the [3]Frequently Asked Questions about the GNU Licenses. What follows is a brief rundown on those changes, and how you can learn more about free software licensing.

Commons Clause

We added the [4]Commons Clause to our list of nonfree licenses. Not a stand-alone license in and of itself, it is meant to be added to an existing free license to prevent using the work commercially, rendering the work nonfree. Itʼs particularly nasty given that the name, and the fact that it is attached to pre-existing free licenses, may make it seem as if the work is still free software.

If a previously existing project that was under a free license adds the Commons Clause, users should work to fork that program and continue using it under the free license. If it isnʼt worth forking, users should simply avoid the package. We are glad to see that in the case of Redis modules using the Commons Clause, people are [5]stepping up to maintain free versions.

The Fraunhofer FDK AAC license

We recently added the [6]Fraunhofer FDK AAC license to our list of licenses. This is a free license, incompatible with any version of the GNU General Public License (GNU GPL), but also contains a potential trap. While Fraunhofer provides a copyright license here, they explicitly decline to grant any patent license. In fact, they direct users to contact them to obtain a patent license. Users should act with caution in determining whether they feel comfortable using works under this license.

License Compatibility

In September, we added a new section to our article on [7]License Compatibility and Relicensing, addressing combinations of code. This new section helps you to simplify the picture when dealing with a project that combines code under multiple compatible licenses. If complying with one license necessarily means compliance with the other, then you can reduce the question of complying with both in the following manner:

"[Y]ou start with a list of all the pertinent licenses. Then you can delete from the list any license which is subsumed by another in the list.

We say that license A subsumes license B when compliance with license A implies compliance with license B."

The updated section then goes on to list various examples of this in action. The list may be expanded in the future to cover more cases.

Translated Code

Finally, there is a new addition to our Frequently Asked Questions about the GNU Licenses, with an entry explaining [8]what the GNU GPL says about translating code into another programming language. In short, since copyright law treats a translation as a modified version of a work, translating a program into another programming language has the same consequences as creating a modified version.

How to learn more

These updates touch upon quite a few different resources that we make available, but thatʼs only the start of the materials we provide that can help you to understand free software licensing. For an overview of the resources available, visit us at [9]https://www.fsf.org/licensing, or if you have questions, you can ask the Compliance Lab directly by emailing [10]licensing@fsf.org. The Compliance Lab is our resource on free software licensing, providing materials and expertise to free software users and developers everywhere. Hereʼs what you can do to help keep this vital program going strong:

References

Visible links
1. https://www.gnu.org/licenses/license-list.html
2. http://www.gnu.org/licenses/license-compatibility.html
3. https://www.gnu.org/licenses/gpl-faq.html
4. https://www.gnu.org/licenses/license-list.html#comclause
5. https://goodformcode.com/
6. https://www.gnu.org/licenses/license-list.html#fdk
7. http://www.gnu.org/licenses/license-compatibility.html
8. https://www.gnu.org/licenses/gpl-faq.html#TranslateCode
9. https://www.fsf.org/licensing
10. mailto:licensing@fsf.org

HackerNewsBot debug: Calculated post rank: 100 - Loop: 156 - Rank min: 100 - Author rank: 51

 


Zig – a programming language designed for robustness, optimality, and clarity – Andrew Kelley, March 20th, 2018 Localhost is a series of monthly technical ta...
Article word count: 220

HN Discussion: https://news.ycombinator.com/item?id=18422631
Posted by luu (karma: 54333)
Post stats: Points: 137 - Comments: 59 - 2018-11-10T18:23:08Z

\#HackerNews #perfect #should #software #video #zig
Article content:




[1]IFrame

Zig – a programming language designed for robustness, optimality, and clarity – Andrew Kelley, March 20th, 2018

Localhost is a series of monthly technical talks in NYC, open to the public, and given by members of the Recurse Center community. Go to [2]https://www.recurse.com/localhost for more info.

Abstract: Zig is an LLVM frontend, taking advantage of libclang to automatically import .h files (including macros and inline functions). Zig uses its own linker (LLD) combined with lazily building compiler-rt to provide out-of-the-box cross-compiling for all supported targets. Zig is intended to replace C. It provides high level features such as generics, compile time function execution, and partial evaluation, yet exposes low level LLVM IR features such as aliases. The Zig project believes that software can and should be perfect. Let the Zig Zen guide your spirit down the most optimal path.

Bio: Andrew is an open source programmer, interested in electronic music production and video game development. In the Fall 2013 batch he worked on a music player server and a 3D spaceship flight simulator. Andrew is a backend engineer at OkCupid, and working on open source software nights and weekends.

About RC: The Recurse Center runs educational programming retreats in New York City. The retreats are free, self-directed, project based, and for anyone who wants to get dramatically better at programming. Learn more at [3]https://www.recurse.com.

References

Visible links
1. https://www.youtube.com/embed/Z4oYSByyRak
2. https://www.youtube.com/redirect?v=Z4oYSByyRak&redir_token=ZAkuKVtQZMobxsdcgyPpYe4pNZ58MTU0MTk5MDgyMkAxNTQxOTA0NDIy&event=video_description&q=https%3A%2F%2Fwww.recurse.com%2Flocalhost
3. https://www.youtube.com/redirect?v=Z4oYSByyRak&redir_token=ZAkuKVtQZMobxsdcgyPpYe4pNZ58MTU0MTk5MDgyMkAxNTQxOTA0NDIy&event=video_description&q=https%3A%2F%2Fwww.recurse.com

HackerNewsBot debug: Calculated post rank: 111 - Loop: 163 - Rank min: 100 - Author rank: 163

 

Operating systems – can we make them private?


Every #operating #system (and #application) ever created becomes less #private with each new version.

As technology has evolved, developers are under increasing pressure to spy on their #customers and extract their #data for #exploitation.

Users are always advised to update their #software to improve its #security, its #interface and embrace new features – sometimes with good reason (like #patching a known #vulnerability). Other times the #developer is simply adding spyware. Some 'useful' applications are designed solely as #spyware and do nothing but #collect data.

As most here know, the #OS with the biggest data collection appetite is Windows 10 . #Microsoft have invested their time and money into a #business model that demands its online products extract user data to drive their #ad #targeting #revenue #streams.
Gone are the days when we could install an OS from a CD or have a choice to accept or reject an update.

#Windows is no longer a product but a “service” and with #services come #fees. Microsoft will charge for its OS’s in future. Even #windows7 will incur fees for users who prefer it to #windows10 from January 2020, the cost will rise each year.

Microsoft 'Confirms' Windows 7 New Monthly Charge

https://www.forbes.com/sites/gordonkelly/2018/09/08/microsoft-windows-7-monthly-charge-windows-10-free-upgrade-cost/

Above link details

This site sets 1 long-term and 2 short-term cookies we can delete. It uses a MEDIUM number of third party embeds (16) that set 3 short-term and 0 long-term cookies. 2 tracker companies do not set cookies although Disconnect blocked 18 trackers.

Windows 10 has had 3 major update scandals this year alone where #devices frozen or random files were #deleted.

Thousands of Windows 7 & 8 users have had their devices upgraded to 10 without their permission, while many businesses are refusing to change from Windows 7 forcing Microsoft to extend their support for it.

I will try to explain how we can make Windows 10 #safer in future posts but users will have to face the fact that

Microsoft's Software is Malware


Furthermore it contains backdoors. I have tested this myself. I’ve turned off all updates on a Windows 7 device yet have still received updates! These were flagged up by Windows 7’s event manager – ironically, a Microsoft product betraying another Microsoft product. However, I did not disable updates in the #registry on that #device – the surest way of truly stopping updates – because one mistake can trash the system. The #hacking #community tells me they have developed a souped-up version of #XP running with all #backdoors closed, although I have no proof of this.

Microsoft's Software is Malware

Above link details

This site sets NO long-term or short-term cookies. It uses a NO third party embeds and NO tracking companies.
It is very rare
#privacy

 
Hallo #Fediverse #Community,

heute muss ich euch mal um Hilfe bitten, kennt jemand zufällig eine nette leichtgewichtige Alternative zu #Paperless ? Aktuell suche ich nach einem #Dokumentenverwaltungstool - #Software zum selbst #hosten welches #OpenSource ist.

#followerpower #boosts #

 
Trotz Mitarbeiterprotesten: Amazon will Rekognition weiter an US-Behörden verkaufen #Amazon #AWS #Gesichtserkennung #JeffBezos #Software

 
Berlin: Softwarefehler bringt S-Bahn zum Stehen #ÖPNV #BVG #Software #Unternehmenssoftware #Applikationen #Wirtschaft

 

Against software development


Take with a grain of salt. I. The basic Darwinist tragedy of software engineering is this: Beautiful code gets rewritten; ugly code survives. Just so, generic code is replaced by its concrete…
Article word count: 351

HN Discussion: https://news.ycombinator.com/item?id=18414379
Posted by octosphere (karma: 3091)
Post stats: Points: 111 - Comments: 66 - 2018-11-09T14:06:51Z

\#HackerNews #against #development #software
Article content:

Take with a grain of salt.

I.

The basic Darwinist tragedy of software engineering is this:

Beautiful code gets rewritten; ugly code survives.

Just so, generic code is replaced by its concrete instances, which are faster and (at first) easier to comprehend.

Just so, extensible code gets extended and shimmed and customized until under its own sheer weight it collapses, then replaced by a monolith that Just Works.

Just so, simple code grows, feature by creeping feature, layer by backward-compatible layer, until it is complicated.

So perishes the good, the beautiful, and the true.

In this world of local-optimum-seeking markets, aesthetics alone keep us from the hell of the [1]Programmer-Archaeologist.

II.

Code is limited primarily by our ability to manage complexity. Thus,

Software grows until it exceeds our capacity to understand it.

Because of this, creating large software systems requires making and enforcing decisions about problems beyond any one personʼs ability to understand. Making collective decisions is the core problem of society, government, and culture. After 14,000 years, [2]we [3]still [4]fuck [5]up [6]a [7]lot. As software [8]eats the world, we should expect our collective decision-making systems to be badly stressed for the foreseeable future.

Perhaps we should expect true advances in software “engineering” only when we learn how better to govern ourselves.

III.

To those who have a choice:

Refuse to work on systems that profit from digital addictions. Refuse to work on systems that centralize control of media. Refuse to work on systems that prop up an unjust status quo. Refuse to work on systems that require unsustainable tradeoffs.

Refuse to work on systems that weaponize the fabric of society.

Above all, refuse to work on systems that understand and manipulate people, but offer no affordance for their subjects to understand and manipulate them.

Work on something that matters, if only to you. Work on something that helps people, even in small ways.

Work on making things understandable.

Once, software let us escape to virtual worlds, choose our own communities, and explore alternate realities. These days, for better or worse, software defines everyoneʼs reality. Letʼs build one worth living in.

References

Visible links
1. http://lambda-the-ultimate.org/node/4424
2. https://en.wikipedia.org/wiki/Global_warming
3. https://en.wikipedia.org/wiki/List_of_states_with_nuclear_weapons
4. https://www.motherjones.com/kevin-drum/2018/02/an-updated-lead-crime-roundup-for-2018/
5. https://en.wikipedia.org/wiki/Prison%E2%80%93industrial_complex
6. http://politicalscience.yale.edu/publications/seeing-state-how-certain-schemes-improve-human-condition-have-failed
7. http://ncase.me/polygons/
8. https://a16z.com/2016/08/20/why-software-is-eating-the-world/

HackerNewsBot debug: Calculated post rank: 96 - Loop: 119 - Rank min: 80 - Author rank: 56

 

How to Design Software Good


HN Discussion: https://news.ycombinator.com/item?id=18409514
Posted by davisr (karma: 258)
Post stats: Points: 156 - Comments: 38 - 2018-11-08T20:09:34Z

\#HackerNews #design #good #how #software
HackerNewsBot debug: Calculated post rank: 116 - Loop: 205 - Rank min: 100 - Author rank: 47

 
VMware: In jeder AWS-Verfügbarkeitszone soll es auch VMware geben #VMware #CloudComputing #Kubernetes #PatGelsinger #RedHat #Software #Unternehmenssoftware #Virtualisierung #IBM #Applikationen

 
[free software for editing images in the browser](https://dia.so/2xC

implemented as progressive web app for better integration in modern browsers. no raw file support beside #DNG yet, but can open and edit many formats.

[there is already an AMA on Reddit from the author](
https://www.reddit.com/r/IAmA/comments/9urjmg/i_made_a_free_alternative_to_photoshop_that_is/

#photoshop #editor #images #webapp #software

 

Energieeffizienz bei Software


Wichtiges Thema, Diskussion dazu bitte im Original-Post...
Ich denke, dass das Thema Energieeffizienz bei Software eine noch viel
zu geringe Bedeutung hat. Dabei gäbe es gerade hier große Einsparpotenziale,
wenn alte Rechner länger genutzt werden könnten, weil aktuelle Software
auf ihnen noch schnell läuft. Die Einsparpotenziale beziehen sich auf
die Herstellung neuer Hardware und das Recycling alter Hardware, falls
letzteres überhaupt gemacht wird.


Bei Webseiten scheint das Thema Energieeffizienz unwichtig zu sein, wenn ich sehe,
wie viele Seiten erst nach dem Zulassen von JavaScript damit beginnen,
ihren Inhalt preiszugeben. Oft genug sind diese Seiten auf alter Hardware
dann sehr langsam, manchmal sogar zu langsam. Und so mancher wird sich dann
sagen "Ok, mein Rechner ist zu alt, ich brauche einen neuen" und der alte
Rechner wird unnötig entsorgt, nur weil Webentwickler nicht auf
Energieeffizienz geachtet haben.


Um einen Eindruck davon zu haben, wie gut eine Software mit alten Computern
lauffähig ist, bietet es sich an, die Software auf einem Raspberry Pi
laufen zu lassen und zu schauen, wie gut sie dort benutzbar ist:
- Lädt die Software innerhalb von Sekunden oder braucht sie Minuten?
- Kommt sie mit wenig Arbeitsspeicher zurecht oder braucht sie Hunderte von Megabyte?
- Ist sie gut bedienbar oder dauert es mehrere Sekunden von der Aktion zur Reaktion?

Auch bei Webseiten kann der Raspberry Pi als Referenz dienen:
- Lädt die Seite innerhalb weniger Sekunden oder braucht sie Minuten?
- Wie lange dauert es, bis eine Aktion ausgeführt wird? Sekunden oder Minuten?
- Wie ist die Prozessorauslastung bei der Nutzung der Seite? Dauerhaft auf 100% oder nur beim Laden von Inhalten?




Es gibt zu viel Elektronik, die umsonst weggeworfen wird. Machen wir uns doch
Gedanken darum, wie wir freie Software so schreiben können, dass sie auch auf
alter Hardware lauffähig ist.

#Energieeffizienz #Software #Hardware #Obsoleszenz #Webseiten #Websoftware
#Gedanken

#Umwelt #Energiesparen

 
Ich denke, dass das Thema Energieeffizienz bei Software eine noch viel
zu geringe Bedeutung hat. Dabei gäbe es gerade hier große Einsparpotenziale,
wenn alte Rechner länger genutzt werden könnten, weil aktuelle Software
auf ihnen noch schnell läuft. Die Einsparpotenziale beziehen sich auf
die Herstellung neuer Hardware und das Recycling alter Hardware, falls
letzteres überhaupt gemacht wird.

Bei Webseiten scheint das Thema Energieeffizienz unwichtig zu sein, wenn ich sehe,
wie viele Seiten erst nach dem Zulassen von JavaScript damit beginnen,
ihren Inhalt preiszugeben. Oft genug sind diese Seiten auf alter Hardware
dann sehr langsam, manchmal sogar zu langsam. Und so mancher wird sich dann
sagen "Ok, mein Rechner ist zu alt, ich brauche einen neuen" und der alte
Rechner wird unnötig entsorgt, nur weil Webentwickler nicht auf
Energieeffizienz geachtet haben.

Um einen Eindruck davon zu haben, wie gut eine Software mit alten Computern
lauffähig ist, bietet es sich an, die Software auf einem Raspberry Pi
laufen zu lassen und zu schauen, wie gut sie dort benutzbar ist:
- Lädt die Software innerhalb von Sekunden oder braucht sie Minuten?
- Kommt sie mit wenig Arbeitsspeicher zurecht oder braucht sie Hunderte von Megabyte?
- Ist sie gut bedienbar oder dauert es mehrere Sekunden von der Aktion zur Reaktion?

Auch bei Webseiten kann der Raspberry Pi als Referenz dienen:
- Lädt die Seite innerhalb weniger Sekunden oder braucht sie Minuten?
- Wie lange dauert es, bis eine Aktion ausgeführt wird? Sekunden oder Minuten?
- Wie ist die Prozessorauslastung bei der Nutzung der Seite? Dauerhaft auf 100% oder nur beim Laden von Inhalten?

Es gibt zu viel Elektronik, die umsonst weggeworfen wird. Machen wir uns doch
Gedanken darum, wie wir freie Software so schreiben können, dass sie auch auf
alter Hardware lauffähig ist.

#Energieeffizienz #Software #Hardware #Obsoleszenz #Webseiten #Websoftware
#Gedanken

 
PdfBooklet bietet eine flexible Alternative zum klassischen Broschürendruck. Auch nicht DIN-kompatible Seitenformate sind damit kein Problem. #Broschürendruck #Drucken #Layout-Tool #PdfBooklet #Software

 
Security: Google-Anmeldung fordert künftig eingeschaltetes Javascript #Google #CloudComputing #GoogleDrive #Hacker #Javascript #Software #Zombie #Applikationen #Security

 
Apple: Es ändert sich einiges bei der App-Entwicklung für das iPad #iPad #App #Software #Tablet #iOS #Apple #Softwareentwicklung #Mobil

 

Sales mistakes that software engineers make


Everybody is selling something. For software engineers this can translate to selling products directly to customers on the front lines or selling new product feature ideas internally within an…
Article word count: 2589

HN Discussion: https://news.ycombinator.com/item?id=18351891
Posted by Fergi (karma: 409)
Post stats: Points: 135 - Comments: 29 - 2018-11-01T07:13:09Z

\#HackerNews #engineers #make #mistakes #sales #software #that
Article content:

Everybody is selling something.

For software engineers this can translate to selling products directly to customers on the front lines or selling new product feature ideas internally within an organization. In either case, sales in some form cannot be avoided. As such, software engineers can benefit greatly from observing and avoiding the more impactful and common mistakes other developers have made in the past, and learning what they should have done instead.

When we went through Y-Combinator during the winter of 2014 and were just starting [1]PipelineDB, one of the things that surprised me most about the other founders in our YC batch, who were mostly technical, was their bewilderment at the prospect of selling. Here were some of the most brilliant minds I’d ever met, building things ranging from self driving cars to aerial imagery analytics platforms for agriculture, and the aspect of their startups that seemed to cause them the most anxiety was sales.

And then it occurred to me that it wasn’t because sales is prohibitively complex or difficult that these genius technical minds were baffled by it. It was simply a situation where they didn’t know what they didn’t know. Ambiguity is inherently stressful.

This post aims to help software engineers bridge the gap between conceptualizing valuable software products and winning deals by observing three significant mistakes developers commonly make when approaching sales. We’ll frame these mistakes in a positive light, more as opportunities for progress than as liabilities, focusing on solutions in each instance.

Each of these mistakes is fairly unintuitive, so it’s not surprising that any salesperson, including software engineers, would make any of them.

Sales Mistake #1 - Building Before you Start Selling

The biggest mistake I see developers make is assuming that they are building something that people both want and will pay a meaningful amount of money for. Many engineering teams spend a great deal of time and money building products that people either don’t actually want, or want but aren’t willing to pay enough money for, such that the company building the product can establish a feasible business model. Both of these issues can be resolved simply by talking to potential customers before the product is ever built and asking strategic questions, a step which many developers fail to take.

Ironically, the amount of work required to talk to potential customers and prove demand for a potential product is almost exactly the same as the amount of work required to sell an existing product. So, the sales work we’re talking about here has to be done at some point, regardless. One benefit of doing this sales work in advance of building the product is that if you’re right about the extent to which people want what you’re building, you’ll be lining up customers for sales as soon as the product is ready and learning more about what features people need and will pay for in the process. If you’re wrong, you’ll save time and money by not building something people don’t want.

Plus, if you’re a startup looking to raise money and haven’t built the product yet, or are working at a company and looking to win internal support for the development of a new product or feature, there is no better ammunition for pitching investors or internal champions than hard, documented customer demand. This documented customer demand will carry weight only if it demonstrates a propensity, or better yet, a contractual obligation, to pay a meaningful amount of money for whatever you’re building.

Strategically engaging with and selling to potential customers before you build your product is a far superior strategy than building a product and then taking it to customers and trying to sell it, so do yourself a gigantic favor and check your assumptions before you start building and test your hypothesis about both people’s interest and willingness to pay for what you want to build, before you build it. No amount of salesmanship will enable you to make up for building the wrong product.

So how do we accomplish this? Below is a quick overview of the steps required to find and engage potential customers, along with a couple of helpful tools and strategies to help you get the job done.

1. Clearly articulate your hypothesis about what you’re building. What is the product? Who wants this? Why do they want it? What will they pay for it? How do you know they’ll pay that much? How many potential customers exist? Be as concise as possible with your answers to these questions. The simpler the response, the better. Without a well thought through hypothesis you’ll have nothing to test or measure against.

2. Create a list of companies (or users) that you think fit your hypothesis in a spreadsheet or simple CRM (customer relationship management) tool like [2]Streak, a lightweight CRM offered as a Gmail plugin. This CRM will be your data management platform for all customer interaction and can be used to organize your target list of companies, monitor your sales progress, document customer conversations and feedback, and ultimately measure your sales results.
The most common way to organize a CRM is by grouping companies you’re targeting by the stage of the conversation that each company is in with you. I’d suggest using (“lead”, “reached out”, “active contact”, “demo/free trial”, “closed/won”, “closed/lost”, and “future interest”) or some close variant, as your stage names. It is imperative to have and use a well organized CRM of some sort, even if it’s just a simple spreadsheet.

3. Find relevant contacts at each company on your target list and document their names, titles, and contact information in your CRM. You can use [3]LinkedInʼs search feature to find employees who work at each company you’re targeting, along with their titles and oftentimes descriptions of their roles. You can also browse the “about us” section of the websites of the companies you’re targeting and conduct basic Google searches to find the names and titles of employees you want to talk to. Try to identify a handful of relevant contacts at each company. Having multiple points of entry for each company increases your chances of successfully setting up a meeting with that company, which should be your goal.
You can use tools like Linkedin’s [4]Sales Navigator Gmail plugin (was called Rapportive) to help you find contact info for the folks on your list. If you don’t connect with the right contact initially, ask the person you do connect with who they would suggest you talk to and if they’d be willing to make a quick email introduction to that person. I’m always surprised at people’s willingness to be helpful when I’m direct, sincere, and respectful of their time. And work your own personal network. The best introductions are warm intros from people you already know, so leverage your network as much as possible.

4. Reach out to each of the contacts you found. In my experience, the optimal strategy is to write concise and highly personalized outreach emails to each contact explaining who you are, why you’re reaching out, and why they should care. Conclude by asking if they would be open to a brief introductory conversation with you to learn more about your product and how it might help them. The goal is to get them on the phone to discuss your product and test your hypothesis from step one.

Effective selling requires a thoughtful strategy, rigorous effort, and tenacity. There is obviously more to sales than can be articulated in this post alone, but this high-level framework for finding and engaging potential customers is something that software engineers can use to get sales conversations started and generate the type of crucial customer feedback discussed above, before building. Be scrappy and creative in how you find and engage contacts, but make sure that you don’t stop until you have a significant amount of clear feedback that either proves or disproves your hypothesis. And don’t be afraid to iterate on your hypothesis and pivot your product strategy or business model. Iteration is a normal and expected part of a successful product development process, so let go of any attachment you have to what you think people want, and build what they tell you they actually want and will pay for instead.

Sales Mistake #2 - Talking Instead of Listening

The second biggest mistake I see developers make in the sales process is entering into sales conversations with potential customers and proceeding to immediately talk about product features and perceived benefits for the customer, without taking advantage of the opportunity to ask strategic, open-ended questions, and then listen intently. The responses that customers give to thoughtful, open-ended questions inform how customers think about their problems, needs, budgets, timeline, decision making process, fears, alternative options to your product, and the extent to which they perceive that your product solves their problem.

When it comes to sales, it does not matter what you think about your product. It only matters what customers think about your product. In order to win customers you must set aside your own thinking and get into the mind of your customer. The best way to do this is by asking good questions, and then listening carefully and taking notes. Open-ended questions like:
\* How do you think about this problem? 
 \* To what extent is this a priority? 
 \* Why are you interested in this topic? 
 \* How will the decision to do this or not be made? 
 \* What are your most important considerations with this type of project? 
 \* How exactly did this need surface in the first place? 
 \* What would solving this problem do for your team, and the business as a whole?

are particularly effective sales questions because they offer the sales prospect an opportunity to respond with a large volume of unbiased feedback to each of your questions. The goal is to get sales prospects talking about their thought process so that you can understand their perspective, needs, and motives. Without this information you are essentially flying blind in the sales process and likely inundating sales prospects with information that may or may not be relevant. With this information you can deliver a concise, tactical proposal about how your product would add value for them, or determine that your solution actually isn’t a good fit for them and save both you and the prospect time by disqualifying them and moving on to another sales conversation that is likely a better fit.

Many engineers Iʼve talked to report experiencing social anxiety and a sense of discomfort during sales conversations. This is especially true when itʼs time to ask sales prospects some of the harder questions surrounding their willingness to pay for your product, budgets, next steps, and getting all of the decision makers on their end involved and taking action. The natural human response to this type of discomfort is to react somehow, oftentimes by talking unnecessarily, which is a tactical mistake. The optimal approach to sales is to ask the kind of strategic, open-ended questions mentioned above, then wait. Listen. Let the silence linger longer than youʼre comfortable with, so that the sales prospect can consider your question, experience their own emotions, and then respond. Get comfortable being uncomfortable.

Asking good questions is the key to sales. This key can be used to unlock the door to the customer’s thought process. Once the door is open, valuable information can be passed from the customer to you, enabling you to deliver value to the customer. And by delivering value, you will earn revenue.

Sales Mistake #3 - Mistaking Interest for Demand

Software engineers, especially those who are emotionally attached to the value propositions they assume their products’ deliver, have a tendency to mistake interest for demand. If you’re building a product that delivers any incremental value, you’ll likely be able to win the interest of potential users, but that does not mean that you have created enough incremental value for customers to make them willing to pay you a meaningful amount of money for your product. The delta between enthusiasm and willingness to pay is the difference between interest and demand.

What typically happens is that customer prospects will express some level of enthusiasm about a product during a sales call, or even go as far to articulate that they want and would use the product in question. This response from the customer is then interpreted as proof that customers want to buy the product. Software engineers in this situation have a tendency to assume that their sales work is now done and that the only remaining step is to deliver the product and collect their cash. This is incorrect.

More investigation must be conducted to determine whether or not the customer is willing to pay for the product, and if so, how much they are willing to pay. The acronym “BANT” (budget, authority, need, timeline), which was developed by IBM salespeople for qualifying sales leads, is a useful checklist for determining whether not a sales prospect has demonstrated demand for your product. If you can determine that a customer truly:

1. needs your product
2. has enough budget to purchase your product at a price that works for you
3. that you are in contact with a person who has the authority to make the purchase
4. that the transaction will likely be completed in a timeline that is acceptable to you

then you have successfully bridged the gap between interest and demand. Once you have determined that a sales lead has met these criteria, ask them if they’d be willing to sign an agreement to purchase your product at a specific price if it meets a certain set of requirements. The ideal situation for you is to have as many signed, legally binding customer contracts as possible, as early on in the product development process as as possible. You may not be able to get these, but you should try. Even getting customers to sign non-binding “letters of intent” to purchase your product, ideally at a set price, is valuable and can be used to build your case to any relevant parties. You must push customers to agree to as much as possible. Without doing this, you will not have a good sense for the extent to which demand for your product exists.

Don’t fall into the trap of mistaking people’s enthusiasm and language around how much they want and will use your product for real demand that satisfies your business hypothesis. It’s possible to waste an infinite amount of time chasing unqualified leads, or worse, mistaking interest for demand and building the wrong product entirely.

Conclusion

The majority of software products and companies that fail do so because they neglect to perform the kind of thorough customer development work described above. The process of strategically engaging customers and transforming their feedback into valuable software products is the best way to ensure that you build something that delivers enough value to these customers for them to be willing to pay you a meaningful amount of money in return.

This iterative process of talking to customers and building what they need and will pay for is not only an exercise to be conducted before building products, but should also serve as a continuous feedback loop between customers and developers. Don’t deny yourself the opportunity to harvest mission-critical information needed to build game changing software products that support successful business models, simply by neglecting to engage the very people you’re aiming to help.

Talk to your customers, build what they want and will pay for, and iterate relentlessly.

References

Visible links
1. https://www.pipelinedb.com/
2. https://www.streak.com/
3. https://www.linkedin.com/
4. https://chrome.google.com/webstore/detail/linkedin-sales-navigator/hihakjfhbmlmjdnnhegiciffjplmdhin?hl=en

HackerNewsBot debug: Calculated post rank: 99 - Loop: 72 - Rank min: 80 - Author rank: 45

 
Apple requires devs to support iPad Pro 3 or iPhone XS Max by March 2019 Apple requires devs to support iPad Pro 3 or iPhone XS Max by March 2019 https://venturebeat.com/2018/10/31/apple-requires-devs-to-support-ipad-pro-3-or-iphone-xs-max-by-march-2019/ #software #hardware
Apple requires devs to support iPad Pro 3 or iPhone XS Max by March 2019

 
Hey people I'm #newhere I'm interested in #metal music and play guitar. I'm also into #developing and #testing #software

 

My somewhat complete salary history as a software engineer


It’s 2018 and somehow women are still getting paid less than men, even in supposedly progressive industries like software. [1]Whether that be from companies offering women less than men for the same…

HN Discussion: https://news.ycombinator.com/item?id=18342996
Posted by jodooshi (karma: 665)
Post stats: Points: 137 - Comments: 64 - 2018-10-31T02:50:52Z

\#HackerNews #complete #engineer #history #salary #software #somewhat
Article content:

Bild/Foto

It’s 2018 and somehow women are still getting paid less than men, even in supposedly progressive industries like software. [1]Whether that be from companies offering women less than men for the same position, women being less likely to negotiate or less successful in negotiations, or any of the other myriad reasons, the results are still the same: women make less than men for the same job. That’s something that shouldn’t be happening in today’s world and it’s up to us (read: men) to step up and make things right. This is my attempt to do just that.

Why am I doing this?

Longtime followers know that I’ve been dealing with serious health issues for several years. Two and a half years ago I had to stop working to focus on my health and it will likely be a couple more years before I’m able to even consider working a full-time job again. The people responsible for my last compensation package have long since left that company. That puts me in a unique position where I am not beholden to any past employers, and any future employers are far enough into the future that the information I’m sharing here will be mostly useless by then. Plus, as a white man, I know I’m going to be able to negotiate for my salary without backlash [2]when I do start working again. As such, the information in this post is more valuable to others than it is to me.

As an aside, I’ve been annoyed that throughout my career I’ve been lectured many times to avoid discussing my compensation with colleagues. Usually it’s with the warning that, “not everyone is getting what you’re getting, and we don’t want to hurt feelings.” It took me a long time to realize that the “hurt feelings” they’re talking about come from an overall lack of transparency into the compensation process, and that simply explaining why people are compensated in certain ways would be a better solution than to hide all of the information from everyone. Yes, there will always be people who think they deserve to be making more but who don’t actually deserve it. That seems like a great way to communicate that they aren’t doing a good enough job and figure out ways to improve.

The bottom line is that nothing gets better unless people are willing to share information. And while I could just share my last salary, I don’t think that’s very useful, especially when compared with the variety of already-available sources of information online. No, to be useful, I felt like I would need to reveal my entire salary history so people can determine for themselves if they’re seeing enough improvement in their salaries over time.

Where did this data come from?

The data in this post comes from the following sources:

1. My memory. Yes, memory is fallible, but there are some data points that are so important on an emotional level that they tend to stick in my brain. I’ll point those out.
2. Offer letters. As my offer letters post-2006 were always emailed to me, I’ve been able to be 100% sure of those details. Prior to 2006, my offer letters were always mailed to me, and I have no record of those.

Where my memory fails me and I don’t have an offer letter, I’ve made an attempt to guess the salary range I had at the time.

The data

The table below contains all of my salary (and some other compensation history). I’m including what I believe to be data relevant to evaluating the compensation include the year I received the salary, the years of experience I had at the time (YOE), the starting and ending salary to take into account raises, and any signing bonus (Signing $) and stock options (Options) I might have received. Any amount with a question mark indicates that I’m guessing. I did not include any restricted stock units I might have received because I only ever received them at Yahoo as part of my initial offer.

Year YOE Company State Title Starting $ Ending $ Signing $ Options
2000 0 Radnet, Inc. MA Webmaster $48,000 $55,000 - ?
2001 0 Radnet, Inc. MA UI Developer $62,500 $62,500 - -
2001 0 MatrixOne, Inc. MA UI Designer/Developer $68,000? ? $2,000 ?
2003 3 MatrixOne, Inc. MA Senior Software Engineer ? $75,000? - -
2005 5 Vistaprint, Inc. MA Lead Software Engineer $82,000? $98,000 - 3,000
2006 6 Yahoo, Inc. CA Senior Front-end Engineer $115,000 ? $10,000 3,500
2008 8 Yahoo, Inc. CA Principal Front-end Engineer ? ? - -
2011 11 Yahoo, Inc. CA Presentation Architect ? $165,000? - -
2013 13 Box, Inc. CA Staff Software Engineer $175,000 ? $25,000 50,000
2014 14 Box, Inc. CA Principal Architect $208,000 $220,000 - -

Job Details

The data alone doesn’t really tell the full story, so here are the details around each position. I’ve also included how I came to work at each company, as I think it’s important to recognize blind resume submissions from having contacts as a company.

In 2006, I moved from Massachusetts to California. This undoubtedly affected my pay positively due to the higher cost of living in California. At one point, my manager mentioned that if I moved back to Massachusetts, I should expect a 10% pay cut due to cost of living differences. I’m still in California, so I have no idea if that was accurate.

Radnet (2000-2001)

My first job out of college was at a small startup in Wakefield, MA called Radnet, Inc. I got this job because the woman who used to babysit me as a child was running human resources at the company. My official title was webmaster, and I thought I would be coming in to run the company website. As it turned out, between the time they offered me the job and my starting day, they had hired someone to oversee both UI development and the website. As it turned out, I would never manage the website and instead would spend time making JavaScript components for the company’s web application.

I know that my starting salary was $48,000 (about $70,284 in 2018 dollars) because I was very excited about it. After spending summers working jobs that ranged from $2/hour to $6/hour, this seemed like an incredible amount of money to me. A few months in, they gave me a raise to $55,000 because I was doing a good job. Towards the end of 2000, they believed the company would be bought and so they changed my title to UI Developer and upped my salary to $62,500 with the belief that an acquirer would immediately fire the “webmaster” and ensuring I’d benefit from the acquisition.

As it turned out, the company never got bought and so it shutdown in January 2001. I never really saw much of the $62,500, and eight months after I had started my first job, I was unemployed.

The job itself was pretty low-stress. I worked an even 40 hours per week during my eight months there, and never once worked on a weekend.

Note: I did receive stock options for this position, but I don’t remember what they were. I didn’t really understand what stock options were at the time so that information never stuck in my brain.

MatrixOne (2001-2005)

When Radnet closed down, my manager ended up at MatrixOne and asked if I would like to join him. I had enjoyed working with him at Radnet so I accepted. It’s important to understand that this was during the dot-com crash and there weren’t a lot of tech jobs to be had in Massachusetts at the time. I considered myself lucky to have formed a good relationship that allowed me to find a new job fairly quickly after Radnet shut down.

I don’t remember all of the details but I’m pretty sure my starting salary was close to $68,000 ($96,814 in 2018 dollars). I’m also reasonably certain that I got a small signing bonus, maybe around $2,000, that my manager negotiated for me. I also received some stock options, but once again, I didn’t really understand what they were and so didn’t even register them as part of my compensation. It didn’t matter, though, because the company stock was never again as high as the day I joined. I was never able to exercise options, even when I got some repriced options later in my career there because the stock only ever went down. (Eventually the company would be bought out by a competitor.)

My salary didn’t improve much there because the company was in perpetually poor financial health. There was a salary freeze in place almost the entire time I was there. I survived four rounds of layoffs. I was eventually “promoted” to the position of Senior Software Engineer, but it was a promotion in title only. There was no increase in salary (because of the salary freeze) and no change in my responsibilities (because the organization was weird). It was just a pat on the back to say, “good job, please don’t leave.” Spoiler alert: I left as soon as I could.

Right before I left, I did get a salary increase to around $75,000. It wasn’t enough to make me want to stay.

In terms of workload, once again I stuck pretty close to 40 hours per week and never worked a weekend. My commute, however, added three hours every day (1.5 hours each way). Adding in the commute time would make it 55 hours per week.

This was the busiest time of my life, as I was not only working full time but was also writing my first book (nights and weekends) and going to school for my master’s degree (nights and weekends). I’m not quite sure how I ended up doing all of that, and managing a serious relationship with my then-partner, but somehow I made it through.

Vistaprint (2005-2006)

I often refer to my position at Vistaprint as my first real software engineering job. It was the first time I applied for a software engineering job without having a connection at the company; I just sent my resume in to their email address. I reported into the engineering organization (as opposed to the design organization in my prior jobs), and I got what I considered to be a good offer. The company was pre-IPO, and I was excited to get 3,000 stock options. (By this time, I actually understood what stock options were.)

I don’t recall the starting salary but I suspect it was around $82,000 ($105,867 in 2018 dollars). I definitely recall the ending salary as $98,000 for a few reasons. First, I was complaining a lot about the boring project they had assigned me to so I expected that would eliminate me from any serious raise considerations. I was shocked to get a raise and even more shocked at the amount. Second, I was bummed they didn’t give me the extra $2,000 to make an even $100,000. Last, I was secretly interviewing with both Google and Yahoo, and upping my salary meant that I could use that number when it came time to talk compensation with them.

I was only at Vistaprint for a little over a year before deciding to move to California to work for Yahoo. Vistaprint did go public while I was there, but since I left after a year, I didn’t see much from those stock options.

The workload here was heavier but I still managed to stick to 40-45 hours per week. I don’t recall working any weekends, however, I do recall sometimes needing to work from home in the evening or early morning. All in all, though, the workload wasn’t that bad.

Yahoo (2006-2011)

Yahoo’s initial offer was the best I had received up to that point. In addition to a $115,000 base salary ($143,833 in 2018 dollars), it included $10,000 signing bonus, 3,500 stock options, 1,500 RSUs, and relocation expenses. This was the first time I tried to negotiate for a higher starting salary and was summarily rejected. At least I tried.

I ended up at Yahoo through a circuitous route. I had heard that Yahoo was using my first book, Professional JavaScript for Web Developers, to teach JavaScript at the company. As such, I had an open invitation to stop by the campus if I was ever in the area. I had traveled to Mountain View to interview Google (they had found me through my second book, Professional Ajax) and so reached out to the folks at Yahoo to meet up. I didn’t realize that conversation would turn into an invitation to apply to work at Yahoo as well.

I don’t remember a lot of my pay details after I joined. Being at Yahoo for almost five years, I got several raises and two promotions, so my pay did keep increasing. All of that information was sent to my Yahoo corporate email address, and as such, I no longer have any of the documentation. That was intermixed with periods of layoffs and salary freezes. My initial stock options ended up worthless because the company stock price never again reached the level it was at when the options were priced. I would later get repriced stock options and more RSUs, but I don’t have specifics on that.

By the time I left, I suspect I was making around $165,000 based on how I felt about the offer from Box.

It’s worth noting that I left Yahoo to try to start a company with some friends and so didn’t have a regular salary for about 18 months.

The workload at Yahoo varied based on the position I had at that time. When I first arrived at Yahoo, I was in a deep depression after moving across the country to a place where I didn’t know anyone. I found being alone in my apartment to be unbearable and so I would go into work early and leave late. Focusing on my work kept the bad thoughts out of my head and I really enjoyed working on My Yahoo, so it was a good mix. I was probably in the office from 9am to 7pm most days.

Once I got more comfortable and started meeting people, I spent less time at the office and settled back into more of a 40-hour work week. Unfortunately, I also got more involved with writing and speaking, and those activities started to fill my nights and weekends. Before I knew it, I was basically working every day from the moment I woke up until the moment I went to sleep. Even though all of the work wasn’t Yahoo was paying me for, it was all the same type of work, so it all flowed together.

The one thing I never did, though, was check my work email from home. I told everyone that leaving the office meant I was off the clock and the only way to reach me was to call me (I did give everyone my cell phone number). In my almost five years at Yahoo, I was only ever called once.

There were several occasions when I had to work over the weekend, but my managers were very good about giving me that time back the next week. If I had to work over the weekend then I could choose the same number of days during the week to take off (I’d usually take Thursday and Friday the next week to get a long weekend).

Box (2013-2016)

My offer from Box was also strong. The starting salary of $175,000 ($189,415 in 2018 dollars) was more than enough to make me happy at the time, and the offer included 50,000 stock options. Box was pre-IPO so that high stock option allocation (which I was told was higher than what they usually gave people at my level) was a big consideration for me. I negotiated for a $25,000 signing bonus, as well.

As part of my consulting business, I would regularly give talks at different companies. I agreed to give a talk for free at Box because a friend worked there and mentioned that they were having trouble managing their growing JavaScript code base. I spoke with a few people after the talk, including the VP of engineering, and we decided to explore if working at Box was a good fit for the company and me. Through several more discussions, it seemed like a good opportunity to get back into the stability of a regular salary with some interesting problems to tackle.

My memory is a bit hazy around what happened between joining and the end of my time at Box as this was the period when my health was on a steep decline. I think I got one raise as a Staff Software Engineer about three months after I joined, and was informed of being promoted to Principal Architect six months after I joined (although I wouldn’t get the pay increase for another six months). I’m reasonably certain the promotion pay increase bumped me to $208,000. I recall clearly that I got one last raise to push me to $220,000 during 2014 because I had started working from home full time due to my health and I thought it was very nice of them to give me a raise regardless.

At Box, I managed my workload very carefully due to my health. I started out at 40 hours per week but as my health declined, that number went down. I definitely dipped below that level later, but since we were evaluated on our impact rather than number of hours worked, I still got consistently positive reviews from my peers and manager. Box was also gracious enough to give me flexibility to work from home for two years, and even then, to work my own schedule as my health allowed. Ironically, it was my declining health that forced me to get smarter about how I worked and really keep my hours sane. I was also not spending time writing and speaking after the first year.

I left Box when I was no longer physically able to work from home.

Conclusion

In my sixteen year career, I averaged a pay increase of $10,000 per year, even when taking into account several years of salary freezes at MatrixOne and Yahoo. As such, I suspect I’d be making around $250,000 if I was working full time today.

It’s also important to understand that I never asked for a raise and only negotiated other details occassionally (as mentioned in the post). I never really felt comfortable with negotiations prior to working for myself, and generally was happy with the offers I received.

With the exception of my one year at Vistaprint (during which I was a grouchy pain in the ass), I was consistently reviewed as a top performer at my position. I wasn’t put on any sort of improvement plan and most of my feedback had to do with improving interactions and communication with colleagues. And again, with the exception of Vistaprint (because…pain in the ass), I took the feedback to heart and worked to improve in those areas.

Being single and not having a family to support throughout my entire career meant that I had more options. I could afford to take salary that was lower than what I wanted or could get elsewhere, and I could also afford to walk away from valuable stock options (such as with Vistaprint) to find a job that was more fulfilling. I recognize that not everyone has that option, so I think it’s important to make my situation clear here.

I have two hopes from sharing this information. First, I hope that having this information will make it easier for women to understand how much they should be paid for similar work and just how their pay should be increasing throughout their career. Second, I hope that other men who are in a similarly independent position will also share their compensation history to benefit others.

We can all be better if we’re willing to share.
\* 30-October-2018 - added in details about hours worked per week based on feedback.

References

HackerNewsBot debug: Calculated post rank: 112 - Loop: 63 - Rank min: 100 - Author rank: 55

 

Over 10 Million Downloads: Meet the Developer of Android's Open Camera


Open Camera has an enviable reputation in the Android camera app world. Google Play shows it with over 10 million downloads and a rating of 4.3 based upon 125,000 comments. That's quite an achievement by any app standards. It's achieved such a standing for a range of reasons, the primary of which is that it's open source, and so, it's free to install and use.

Harman is modest about the capabilities of Open Camera, reluctant to pick out any single feature that impresses, but feels that the breadth of capabilities, particularly linked to the CameraAPI, is what many users like. For those interested in what's coming up, he is currently working on panorama stitching, an on-screen histogram, zebra stripes, and focus peaking.

While users might be interested in the capabilities of third-party camera apps, smartphone manufacturers present problems. Not only is there a wide array of hardware from single through to quad cameras, but manufacturers can decide how much of the hardware to expose to developers. Harman is positive about Android 9, which introduces support for managing them and may lead to some standardization, but there are currently few devices with this installed. Likewise, the Camera2 API has been successful in meeting the demands of developers with Google able to expand its capabilities without the need to release a Camera3 API. He also believes Google is at the forefront of feature development with their HDR+ being a good example of this.

See https://fstoppers.com/originals/over-10-million-downloads-meet-developer-open-camera-299938

#opencamera #Mobile #Software #Photography #Fstoppers

 
Decensoring Hentai with Deep Neural Networks. Formerly named DeepMindBreak.
#nsfw #deeplearning #software #hentai

 

Book Review: A Philosophy of Software Design


I’m trying to read all the good writing about software design. This is very easy because not very much has been written: it turns out that i...
Article word count: 4228

HN Discussion: https://news.ycombinator.com/item?id=18331219
Posted by dailymorn (karma: 194)
Post stats: Points: 156 - Comments: 18 - 2018-10-29T20:44:02Z

\#HackerNews #book #design #philosophy #review #software
Article content:

Bild/Foto

I’m trying to read all the good writing about software design. This is very easy because not very much has been written: it turns out that it’s much easier to write an article about how to write a Tetris AI as a containerized Kotlin microservice than it is to shed insight on how to write good code. And so, when I heard about John Ousterhout’s new book “A Philosophy of Software Design,” I ordered my copy immediately.

I remember John Ousterhout from Stanford’s grad student visit day as the tall guy who introduced himself with a self-deprecating joke and invited all the Ph. D. admits over to dinner at his house. I know him also as the father of [1]Kay Ousterhout, whom I recently met as a fellow speaker at Strange Loop, and Amy Ousterhout, whom together are the first pair of sisters to both win the prestigious Hertz Fellowship.

At 170 pages, “A Philosophy of Software Design” (henceforth: PoSD) is a humble book. John’s background is in systems rather than in software engineering or programming languages, and he never claims special expertise. But his practitioner cred is immense. I enjoy tearing apart open-source projects and turning them into case studies of what not to do, so much that my students have requested I write a case study about good code for once. RAMCloud, Ousterhout’s distributed in-memory storage system, is now on my shortlist: from a 5-minute glance, it’s among the cleanest and best-documented code I’ve seen. And, given that he’s a busy professor managing a large lab, he’s written a surprising amount of it himself. He’s had plenty of impact too: he’s the creator of the Tcl language and its Tk framework, which I learned in 2005 as The Way to Write GUIs(™).

PoSD is best read as a tactical guide of how-to’s. About a quarter of it is spent on naming and comments, and much of the rest is about specific patterns. His few attempts to jump from tactical advice to principles are either done by trying to blur together similar-sounding tips, or are hamstrung by his inability to see the meaning of a program beyond the code (more on that later). He demonstrates the lack of principles comically in Chapter 19, where he promises to apply the books’ “principles” to several software trends, and then fills the rest of the chapter with standard (but solid) advice on unit-testing and OOP, with nary a reference to the rest of the book. On the whole, the book’s advice is higher-level than beginner books like Clean Code, but most of its contents will be familiar to a senior software engineer, and the novel parts are hit-and-miss.

Following other books like [2]Code Simplicity, PoSD starts with a high-minded explanation of the benefits of good code and the dangers of complexity. Its early chapters are a grand tour of the basic concepts of software organization: separating levels of abstraction, isolating complexity, and when to break up functions. Chapter 5 is one of the most approachable introductions I’ve seen to Parnas’s ideas about information hiding. But it’s Chapter 4 where he introduces the book’s central idea: deep modules. An interface, explains Ousterhout, is not just the function signatures written in the code. It also includes informal elements: high-level behavior, constraints on ordering; anything a developer needs to know to use it. Many modules are shallow: they take a lot to explain, but don’t actually do that much. A good module is deep: the interface should be much simpler than the implementation.

Beautiful, obvious, and impossible to disagree with. Unfortunately, it’s also objectively wrong.

When specifications are longer than the code

It sounds pretty nice to say “interfaces should be shorter than the implementation?” How do you test it?

To Ousterhout, where the interface is just a comment and some discussion about whether it’s simple to use and think about. Intuition and experience are the sole arbiters here. And this reveals his major blind spot.

I’ve [3]explained [4]before that the important information of software design is not in the code (Level 2), but in the logic: the specifications and reasoning that are rarely written down concretely, but shape the code nonetheless. I group these artifacts into the aggregate “Level 3 constructs.” The “informal interface” Ousterhout describes is such a Level 3 construct, but they’re just as real as the code, and, contrary to Ousterhout, there are plenty of programming languages that do let you write them down and check them.

Experience doing this gives us concrete grounding when we talk software design. It’s how we move into [5]post-rigorous stage of software engineering, and know what we mean when we use terms like “interface” and “complexity.” It defends us against making confused and contradictory statements. Ousterhout lacks this insight, and that’s how he gets burned.

I’m going to pause for a moment and tell you: I like this book overall. Itʼs well-written, and there’s a lot of advice in the book that I consider useful even though it’s on shaky ground, and more that doesn’t depend on this at all. Still, Ousterhout makes a big deal out of it, and so I’ll be taking a couple pages to explain why it’s wrong. These are ideas are important, because they’re part of what leads to the higher levels of mastery.

My view is that Ousterhout’s “informal interface” is just the translation into English of a formal specification. Any question we have about interfaces can be answered by asking the question “what would a specification look like?” While I can’t prove the correspondence without peaking into Ousterhout’s head more than I’ve gotten to in our back-and-forth, I’ve found this lens unreasonably effective in helping to explain software design. And so, for the remainder of this post, I’ll be using the words “spec” and “interface” interchangeably.

I agree that the spec should usually be much simpler than the code. But anyone with experience actually formalizing specs can tell you that there are interesting cases where the specification is and should be more complicated than the implementation.

Thatʼs right: there are times when it’s actually desirable to have a specification more complicated than the code. Two major reasons are ghost state and imprecision. Ghost state is a concept from verification that describes certain kinds of “subtle” code. It’s an interesting subject that deserves its own blog post; I won’t mention it again. (Short version: it’s when a simple action like flipping a bit actually represents something conceptually complicated.)

Imprecision is a bigger one. For example:
\* Specification: The temperature of the Fudarkameter will be between 60 and 90 degrees. 
 \* Implementation: The temperature of the Fudarkameter is 70 degrees.

The specification is longer precisely because it creates an abstraction barrier. If you design the rest of the system assuming the Fudarkameter is exactly 70 degrees, then the Fudarkameter becomes much harder to change or replace. By weakening the assumptions placed on a module, code becomes more evolvable.

On top of these, there’s another fundamental reason: It is much easier to describe something from the inside than from the outside. It is much easier to show you an apple than to answer every question you may ask of it. (Where are the seeds? How will it roll when I drop it?) And while there is more you can say [6]about a single apple than all the apples in the world, there are more things that may be true about some apple than about a single apple.

As an example, let’s take a stack data structure, something I hope we can all agree is a useful abstraction. A stack is a sequence with push and pop operations, following the last-in-first-out ordering. The linked-list implementation is very short: just adding and removing elements off the front of the list. But if you use a stack, and you don’t want to use internal details of this implementation, then you need a way to think about it that doesn’t reference the underlying sequence. One solution is to use the [7]stack axioms, which say things like “If you push something onto a stack and then pop from the stack, you get the old value back” and “If you’ve ever pushed something onto a stack, then it’s not empty.” We’ve gone from the internal view of explaining how the stack operations manipulate memory, to the external view of explaining their interactions and observable behaviors.

In my public correspondence with Prof. Ousterhout, I illustrated this by writing down an implementation and interface for a stack data structure, including the stack axioms. My implementation was 30 tokens; the interface was 54.

Perhaps you can find a shorter way to explain stacks, but this is not looking good. It seems that Ousterhout’s advice, held under a microscope, is actually telling us we should not use stacks in our code (or, at least, only use the more complicated implementations, like lock-free concurrent stacks).

A “Simple” API

It’s easy for the interface for stacks to be larger than the implementation because they’re so small. Now, let’s look at something larger. I don’t need to look very hard for an example, because Ousterhout gives me one.
The mechanism for file IO provided by the Unix operating system and its descendants, such as Linux, is a beautiful example of a deep interface. There are only five basic system calls for I/O, with simple signatures:

int open(const char* path, int flags, mode_t permissions);
ssize_t read(int fd, void* buffer, size_t count);
ssize_t write(int fd, const void* buffer, size_t count);
off_t lseek(int fd, off_t offset, int referencePosition);
int close(int fd);

The POSIX file API is a great example, but not of a deep interface. Rather, it’s a great example of how code with a very complicated interface may look deceptively simple when reduced to C-style function signatures. It’s a stateful API with interesting orderings and interactions between calls. The flags and permissions parameters of open hide an enormous amount of complexity, with hidden requirements like “exactly one of these five bits should be specified.” open may return 20 different error codes, each with their own meaning, and many with references to specific implementations.

The authors of SibylIFS tried to write down an exact description of the open interface. Their [8]annotated version of the POSIX standard is over 3000 words. Not counting basic machinery, it took them over 200 lines to write down [9]the properties of open in higher-order logic, and another 70 to give the interactions between open and close.

For comparison, while it’s difficult to do the accounting for the size of a feature, their model implementation is a [10]mere 40 lines.

Yes, the real versions in Linux are much longer, even if you don’t count the more general “inode” machinery it’s based on. And you can get by with only a partial understanding of the API. But, having looked at its semantics, a [11]Level 3 artifact, we now have a much truer sense of the complexity of this API beyond the “simple” signature.

There’s a lot that could be done to improve this API, but there’s a fundamental reason why the implementation can be shorter. This is an interface meant to describe every possible implementation of open. Applications that follow it can work with any of them. And so how can it be simpler than the simplest implementation?

So, when coupled with its simpler implementations, open is indeed one of the shallow APIs that Ousterhout reviles. And given how much variety it’s meant to encapsulate, to some extent that’s inevitable.

(Ousterhout’s counterargument is: “You’re just talking about the specification, rather than how easy they are to use to write code that works.” Looking at what’s in the spec, I’d say that knowing how it interprets file paths and what the O_RDONLY flag does are both very much part of knowing how to use it.)

Perhaps a more penetrating example is this write function for a simple replicated disk. This is a system that acts like one disk, but copies everything to two underlying disks, so that it can still run even if one fails. Here’s the write function, transliterated from Coq into C:

void write(addr a, block *b) { disk1->write(a, b); disk2->write(a, b);
}

What’s a spec for this function? Well, it’s written b to both disks — but does nothing to a disk if it’s dead. And if the system crashes midway through, then either neither write succeeded, or the disk1 write succeeded, or both writes succeeded. In Coq:

{| pre := disk0 state ?|= eq d /\ disk1 state ?|= eq d; post := fun r stateʼ => r = tt /\ disk0 stateʼ ?|= eq (diskUpd d a b) /\ disk1 stateʼ ?|= eq (diskUpd d a b); recovered := fun _ stateʼ => write_recover_condition d a b stateʼ ; |}) [...] Definition write_recover_condition d a b stateʼ := (disk0 stateʼ ?|= eq d /\ disk1 stateʼ ?|= eq d) \/ (disk0 stateʼ ?|= eq (diskUpd d a b) /\ disk1 stateʼ ?|= eq d) \/ (disk0 stateʼ ?|= eq (diskUpd d a b) /\ disk1 stateʼ ?|= eq (diskUpd d a b)).

Yes, that’s the internal API. The spec for the external API is simpler, but still longer than the code.

There’s a lot more fun elsewhere in that file. My specs for the recovery procedures total 70 complicated lines, compared to 29 simple lines for the implementation. This is because, when writing this kind of code, you need to constantly be asking “what happens if there’s a crash on this line.” Itʼs easy to miss that and think the code is simple, but the logic lays all bare. Hence, the interfaces are much longer than the code.

So, Ousterhout’s big insight about deep modules is flawed, and advice based on it is unreliable. Using it, he attacks the common wisdom of making small classes/methods, but doesn’t give a way to distinguish when doing so is abstracting something vs. merely adding indirection.

And there are a lot of smaller flaws throughout the book that come from not engaging directly with Level 3 constructs. In an early discussion of coupling, for instance, he discusses how parsing and serialization code for a binary protocol may depend on each other, but it’s more accurate to say that they both depend on the protocol, which is Level 3 and exists outside the code. (Indeed, if you were to use a tool to synthesize a parser from a serializer, you’d do it by first inferring the protocol, and then generating the parsing code from the protocol.)

Into the weeds

After Chapter 9, the book moves away from trying to give broad coding principles into softer territory, as well as more specific coding practices. Chapter 10 “Define errors out of existence” was the most unusual and thought-provoking chapter for me. I came in expecting some cousin of the “make invalid states unrepresentable” stuff that I teach. What I actually found was a pastiche of different tricks for changing the spec of a function to tolerate more inputs/situations.

When I was trying to pin down each piece of advice in this chapter, I found that some of it was actually the opposite of others. In Section 10.9, he implores us to “Design special cases out of existence.” Specifically, he explains how, in a text-editing application, modeling the application state as “a selection always exists, but may be empty” removes the need for special code to handle the case where there is no selection. In other words, take a conditional out of the spec for the function. But in Section 10.5, he tells us that we should add a conditional to the spec of a function, namely in making Java’s substring method defined for out-of-bounds indices. I’m not completely sure he’s wrong (as I discuss in [12]my Strange Loop talk, it comes down to: is there a clean way to describe this behavior?), but I find his claims that this makes the code “simpler” only slightly more credible than his claims about the Unix file API.

The next 7 chapters are the soft parts of the book. Chapter 11 argues that you should consider at least two designs for everything, an instance of multi-tracking in decision-making. The following chapters on comments are well-written if at times moralizing, and I don’t have a solid basis for the parts where I disagree. I strongly approve of his practice of writing “See comment in ” whenever he implements an interface (breaking the hidden coupling between comments). Seeing it in action in the RAMCloud codebase was beautiful.

It’s not until the second-to-last chapter, “Designing for Performance,” that Ousterhout shifts from an enthusiast to an expert. The chapter centers on his “Design around the critical path” concept, reminiscent of [13]Carmack’s comments on inlined code, and a clearly-written case study in RAMCloud. The chapter shines with battle-won experience, and I’d gladly read a book-length from him on this topic. I only wish it had come earlier.

Of names and types

Throughout the second half of the book, I only found two notable pieces of advice that I regard as bad.

Near the end of the book, Ousterhout attacks code like the following:

private List incomingMessageList;

incomingMessageList = new ArrayList();

Why is it being declared as a List even though it’s an ArrayList, Ousterhout asks? Isn’t that making it less obvious? After all, ArrayList’s have their own performance properties.

Yes, but it needlessly ties the code to the specific implementation of ArrayList, and can make the code harder to change. Joshua Bloch thoroughly argues for the opposite advice using an almost-identical example in Point 52 “Refer to objects by their interfaces” in his book Effective Java.

After discussing this example with Ousterhout though, it sounds like he, Bloch, and I are all in agreement. Ousterhout tells people this on the assumption that they wouldn’t be using an ArrayList unless they needed the specific performance guarantees of ArrayList, which is a situation I’ve never encountered. (Conversely, I’ve gotten burned from having to conform to an interface that took ArrayList, when I needed to write something that used less memory.) It’s cutting out details and caveats like this that gives Ousterhout his short book length, but also transmutes sound advice into something ripe for misuse, and destroys a lot of the value it has over raw intuition.

The second piece of bad (well, misleading) advice comes out of a discussion of a pernicious bug in Sprite, a distributed operating system. On rare occasions, some data would be randomly overwritten. The culprit was when an integer representing a logical block within a file (called a “block”) was used as the address of a physical block on the disk (also called a “block”). Echoing [14]Spoelsky, Ousterhout recommends his fix: come up with the perfect name for each variable.

Taking names seriously, and never using the same name for two different concepts, is a good idea. And, [15]as noted before by [16]commenters on Spoelsky, there’s a much better choice for the primary defense mechanism.

The designers of ART, the Java VM that runs on every Android device, had a similar problem. They had many different kinds of pointers which should not be assigned to each other. References to objects controlled by the garbage collector needed to be kept separate from objects internal to the runtime. Some were 64-bit pointers compresesd to 32-bit, and couldn’t be dereferenced directly.

Their insight was that these values are already treated like different types, and there’s hence little complexity cost in making this explicit. Thus, their solution (see: [17]here and [18]here) was to create a separate type for each kind of pointer. Now there is no risk of confusing two such pointers. The compiler can use this information to overload assignment, making code shorter. And it can be done in C++ with zero runtime overhead.

“Use more precise types” is the answer to a lot of software engineering problems.

More Discussion

Ousterhout created a Google group for the sole purpose of sharing feedback on his book, which I find admirable and hope more authors follow. We had several weeks of discussion about this review before I posted it, including big things such as the definitions of “abstraction” and “complexity,” and niche things like the history of the Waterfall method. If you want to see more details of his take on this review, you can read it [19]here.

Summary

PoSD is one of three software design books I’ve read that I’d classify in the “intermediate” category, and the first such book with enough code examples to communicate clearly (though I have a few more candidates on my reading list). PoSD is not a flawless book nor especially original, but it is a good one. He’s collected a lot of advice that’s been roaming around into one thin book, along with some oddballs and handwaving at bigger things. There’s a lot for the junior engineer to learn, and a lot for the senior engineer to reflect on.

I think a lot of people could have written “A Philosophy of Software Design.” But Ousterhout actually did.

Overall Status: Recommend

It may not be groundbreaking, but “A Philosophy of Software Design” is a well-written book with clear examples and solid advice that deserves a place on any junior engineer’s bookshelf.

Quotes and Examples from the Book
Here is an extreme example of a shallow method, taken from a project in a software design class: 

private void addNullValueForAttribute(String attribute) { data.put(attribute, null);
}
From the standpoint of managing complexity, this method makes things worse, not better. The method offers no abstraction, since all of its functionality is visible through its interface. For example, callers probably need to know that the attribute will be stored in the data variable. It is no simpler to think about the interface than to think about the full implementation. If the method is documented properly, the documentation will be longer than the method’s code.

This is a great example of a case of small-class-itis gone wrong. I’ve seen plenty of examples like this myself.

Of course, I can think of a good reason to write a method like this: to hide the decision to use an in-memory map in a handful of functions . But that would be a time to show the abstraction barrier explicitly (e.g.: with an inner class), in accordance with the [20]Embedded Design Principle. “Documentation longer than the code” is a smell of bad code, but not a criterion.
Hiding variables and methods in a class by declaring them private isn’t the same thing as information hiding. Private elements can help with information hiding, since they make it impossible for the items to be accessed directly from outside the class. However, information about the private items can still be exposed through public methods such as getter and setter methods. When this happens the nature and usage of the variables are just as exposed as if the variables were public

I’ve found this to be the most common misunderstanding of information-hiding, and it’s nice to have this written down. I’ll add that it’s also easy to leak information about a private member in more subtle ways. Common example: adding public methods to add/get from an internal data structure, in a fashion where there’s only one sensible implementation consistent with the interface. As Parnas taught us, if a decision can’t be changed without changing other modules, then it’s not a secret.
File deletion provides another example of how errors can be defined away. The Windows operating system does not permit a file to be deleted if it is open in a process. This is a continual source of frustration for developers and users. In order to delete a file that is in use, the user must search through the system to find the process that has the file open, and then kill that process. [...] 

 In Unix, if a file is open when it is deleted, Unix does not delete the file immediately. Instead, it marks the file for deletion, then the delete operation returns successfully. [...] Once the file has been closed by all of the accessing processes, its data is freed. 

 The Unix approach defines away two different kinds of errors. First, the delete operation no longer returns an error if the file is currently in use; the delete succeeds, and the file will eventually be deleted. Second, deleting a file that’s in use does not create exceptions for the processes using the file. [...]

This is a really interesting point by Ousterhout, and I don’t have anything like it in my current teachings on preventing errors. I see this as an instance of the more general operation of simplifying the rely of a function, which simplifies reasoning and eliminates errors. (The “rely” is like a concurrent version of a precondition; see [21]here.
Red Flag: Hard to Pick Name 

 If it’s hard to find a simple name for a variable or method that creates a clear image of the underlying object, that’s a hint that the underlying object may not have a clean design.

Best line in the entire book.
Acknowledgments

Thanks John Ousterhout for his extensive comments on this review (and for writing the book!), as well as to Kieran Barry and Peter Ludemann. Thanks to Tej Chajed for pointing me to SibylFS, and to Adam Chlipala for discussion about when specs can be shorter than the implementation.

References

Visible links
1. http://kayousterhout.org/
2. http://shop.oreilly.com/product/0636920022251.do
3. http://www.pathsensitive.com/2018/01/the-three-levels-of-software-why-code.html
4. http://www.pathsensitive.com/2018/01/the-design-of-software-is-thing-apart.html
5. https://terrytao.wordpress.com/career-advice/theres-more-to-mathematics-than-rigour-and-proofs/
6. http://yudkowsky.net/rational/virtues/
7. http://www.cs.unc.edu/~stotts/204/ADTs/
8. https://github.com/sibylfs/sibylfs_src/blob/8a7f53ba58654249b0ec0725ce3887840d6a1812/fs_spec/src/posix/open.md
9. https://github.com/sibylfs/sibylfs_src/blob/8a7f53ba58654249b0ec0725ce3887840d6a1812/fs_spec/src/t_fs_spec_fs_command_properties.lem_cppo#L460
10. https://github.com/sibylfs/sibylfs_src/blob/8a7f53ba58654249b0ec0725ce3887840d6a1812/fs_spec/src/t_fs_spec.lem_cppo#L4775
11. http://www.pathsensitive.com/2018/01/the-three-levels-of-software-why-code.html
12. https://thestrangeloop.com/2018/you-are-a-program-synthesizer.html
13. http://number-none.com/blow/blog/programming/2014/09/26/carmack-on-inlined-code.html
14. https://www.joelonsoftware.com/2005/05/11/making-wrong-code-look-wrong/
15. https://twitter.com/spolsky/status/815044634170785792
16. https://www.reddit.com/r/programming/comments/126d10/making_wrong_code_look_wrong_joel_on_software/c6skc91
17. http://androidxref.com/9.0.0_r3/xref/art/runtime/mirror/object_reference.h
18. http://androidxref.com/9.0.0_r3/xref/art/runtime/stack_reference.h
19. https://groups.google.com/forum/#!topic/software-design-book/DvnQ1Bvqy30
20. http://www.pathsensitive.com/2018/02/making-bugs-impossible-illustrating.html
21. https://johnwickerson.github.io/talks/rely_guarantee.pdf

HackerNewsBot debug: Calculated post rank: 110 - Loop: 168 - Rank min: 100 - Author rank: 92

 
Bild/Foto
[Image: GhostBSD 18.10]

FreeBSD 12.0-BETA2 + GhostBSD 18.10 RC2


A couple of interesting releases coming for the #BSD community.

#FreeBSD 12.0-BETA2
Release Announcement: ctober/089897.html" target="_blank">https://lists.freebsd.org/pipermail/freebsd-stable/2018-October/089897.html

#GhostBSD 18.10 RC2
Release Announcement: https://www.ghostbsd.org/18.10_RC2_release_announcement

FreeBSD set up can be very technical while GhostBSD is much easier with an installer if your thinking of giving them a test. For a novice I would recommend GhostBSD out of the two and FreeBSD for the little more advanced.

#TrueOS follows FreeBSD "TrueOS follows FreeBSD-CURRENT, with the latest drivers, security updates, and packages available." https://www.trueos.org/more-on-trueos/ so if your not to technical and want to try FreeBSD you could always install TrueOS that is much easier and comes with an installer.

#OpenSource #Software

 
Mega-Übernahme in der IT-Industrie: IBM will Linux-Spezialisten Red Hat schlucken - SPIEGEL ONLINE - Wirtschaft
http://www.spiegel.de/wirtschaft/unternehmen/linux-spezialist-ibm-bietet-milliarden-fuer-red-hat-a-1235604.html#ref=rss
#Wirtschaft #Unternehmen&Märkte #IBM #Software #Linux #CloudComputing

 

Red Hat + IBM: Creating the leading hybrid cloud provider


https://www.redhat.com/en/blog/red-hat-ibm-creating-leading-hybrid-cloud-provider
#linux #ibm #software

 
Bild/Foto

Red Hat will remain a distinct unit in IBM!

Red Hat has signed an agreement to combine forces with IBM in the largest software company acquisition to date... Goo-o-odby Fedora and CentOS?


RedHat Official:
IBM (NYSE:IBM) and Red Hat (NYSE:RHT), the world’s leading provider of open source cloud software, announced today that the companies have reached a definitive agreement under which IBM will acquire all of the issued and outstanding common shares of Red Hat for $190.00 per share in cash, representing a total enterprise value of approximately $34 billion.
MORE: https://www.redhat.com/en/about/press-releases/ibm-acquire-red-hat-completely-changing-cloud-landscape-and-becoming-world%E2%80%99s-1-hybrid-cloud-provider

A few moments ago, Red Hat president and CEO Jim Whitehurst shared this email with Red Hat associates.
MORE: https://www.redhat.com/en/blog/red-hat-ibm-creating-leading-hybrid-cloud-provider
#redhat #ibm #fedora #centos #gnu #linux #rhel #news #cloud #software #os #free

 

IBM Nears Deal to Acquire Software Maker Red Hat


To continue, please click the box below to let us know you're not a robot.

HN Discussion: https://news.ycombinator.com/item?id=18321937
Posted by Immortalin (karma: 2107)
Post stats: Points: 223 - Comments: 100 - 2018-10-28T18:08:19Z

\#HackerNews #acquire #deal #hat #ibm #maker #nears #red #software
Article content:

To continue, please click the box below to let us know youʼre not a robot.

HackerNewsBot debug: Calculated post rank: 182 - Loop: 36 - Rank min: 100 - Author rank: 33

 

5 messaging apps to use when WhatsApp starts showing advertising


WhatsApp is the most popular messaging application in South Africa, but it is also owned by Facebook, a fact that has prompted some users concerned about their privacy to turn to other messaging apps.

There have also been reports that WhatsApp will start showing advertising to users, making it less appealing.

The close relationship between the two platforms and analytical data collected from WhatsApp have alerted many users to potential privacy concerns, and with other apps offering truly private messaging, concerned users have turned to other options for their private conversations.

If your friends are using say three of these networks, not to worry, as most phones will allow you to easily operate multiple messaging platforms simultaneously. In that way you should still stay in contact with everyone. South Africans should also remember they also have Moya Messenger which is zero-rated data within South Africa.

See https://mybroadband.co.za/news/software/281285-5-messaging-apps-to-use-when-whatsapp-starts-showing-advertising.html

#messengers #whatsapp
5 messaging apps to use when WhatsApp starts showing advertising
#Headline #messagingapps #Signal #Status #Telegram #Threema #WhatsApp #Wire #Software

 
Machine Learning: Von KI erstelltes Porträt für 432.500 US.Dollar versteigert #NeuronalesNetzwerk #Bilderkennung #KI #Software #Applikationen

 

Article: Microsoft's acquisition of GitHub has been completed.


by Ian Dorfman, derived from GitHub blog (Nat Friedman).
  • GitHub will operate independently as a community, platform, and business.
  • GitHub will retain its product philosophy.
  • Microsoft's goal is accelerating enterprise use of GitHub, and bringing Microsoft’s developer tools and services to new audiences.


Tags: #Microsoft #GitHub #business #economy #cs #compsci #repository #software #development #foss #opensource #freesoftware #capitalism #natfriedman #devtools #visualstudio #windows #dotnet #api

 
- #Create #Professional #Animations with This #Award-Winning #Software


CrazyTalk Animator 3 Pro is an incredibly simple-yet-powerful piece of software that lets you create a limitless number of eye-catching videos and animations.
https://interestingengineering.com/create-professional-animations-with-this-award-winning-software

 
Manufacturing Cloud: Huawei und Siemens bringen Cloud-Desktops für die Fabrik #Huawei #CloudComputing #Desktop-Management #Software #ThinClients #Unternehmenssoftware #Siemens #Applikationen #Wirtschaft