543 karma · joined November 13, 2014
Integrating with AI and machine learning for over 20 years.
Need help with either of those sticky problems, send me an email.
email: andrewcprock [at] gmail.com
In practice, working in small and medium organizations, I have met very few UX designers. Instead I have met plenty of graphical designers that know almost nothing about UX design. I've been at places where I - as a backend developer - know more about practical UX design than anyone on the design team.
I think the reason why we have "bad mobile first design with awful desktop UX" is because very few of the people designing these experiences are UX designers.
I was surprised the article didn't highlight the horror show that is Vector22 at Wikipedia, a design so colossally bad that after three years of suck costs the only path to saving face was to make it the default theme for all users: "Mission Accomplished!"
One of the main reasons for using cloud infrastructure is that many people know how to use it, internal documentation requirements are dramatically lessened, and you don't need to higher infrastructure IT employees to maintain and monitor it.
If cloud only costs double internal IT, it's almost certainly cheaper until you reach a billion dollar valuation - or more depending on what your infra needs are.
A novice student should be able to generate a working "hello, world" program in 10-20 minutes. This typically means leaving a lot of the software engineering aspect out of the workflow. That's all ok for a novice programmer. It is important for them to engage directly with the workflows.
For example, consider this SWIG tutorial: https://www.swig.org/tutorial.html
Assuming you have a basic editor that you can use (nano) and an environment with all the dependencies installed, you can get a working python plugin built by reading 4-6 sentences, copying data into 2 files, and invoking 3 shell commands. This despite the fact that SWIG is a very deep and complex tool.
The debugging information is really important. I've seen classes where they do not discuss this at all with novice students. Kids need tools to troubleshoot their problems, desk checking code is difficult and only gets more difficult as the length of the programs grow.
The advice on avoiding long expressions is likewise golden. Long expressions are difficult to read, shorter ones are easier to read (this actually applies to variable names well - contrary to the advice in the article).
Finally, the advice on adhering to the DRY principle is not really applicable to novice programmers. Refactoring is hard. Writing library quality code is time consuming. Novice programmers should not be shamed for copy pasting 2-5 lines of code throughout their program. The topic of code organization, libraries, and SOLID principles are things to dig into after a novice has written a couple dozen programs.
I'm sure there are other workflows, especially in the cloud where you are rending out fractions of a CPU. But for individual professionals, what else besides marginal core cost would you consider?
However, I do give NBER full credit for scoring high on the clickbait metric. If you download the actual paper, the word "nerd" only appears in the title of the pdf.
(curiously, and as evidence that nerds don't really go to Harvard, they list Aerospace Engineering as an offered major, but with a participation rate of 0.00% across male/female, athlete/non.)
The map is not the territory.
Patience.
It will be very good at making sure known exploits are not available, but known unknowns and unknown unknowns will remain security blind spots.
I am a staff level engineer focusing on machine learning applications and machine learning operations (MLOps), in support of business systems like search and security. I have a proven track record of architecting, developing and deploying production machine learning systems over a period of ten years in the domains of classification/categorization of text based documents, behavioral data, and images. I am particularly focused on the iterative ML lifecycle: modelling, automation, evaluation/illumination, and experimentation/iteration.
I have deep background in Python, C/C++, and Java, with experience is various ML frameworks (numpy, scipy, pytorch, opencv) and cloud hosted solutions (OpenAI, SageMaker, Google Vision).
It's odd that the article doesn't spell out Zermelo–Fraenkel, and instead uses the shorthand ZFC axioms. At a fundamental level, axioms are simultaneously solid and slippery. The entire purpose of a set of axioms is to serve as a backstop. Without axioms there are no proofs, and instead you wind up riding infinite regress; turtles all the way down. In short, proofs without axioms are impossible.
But once you have a set of axioms, proofs are precisely that, proofs. The notion that mathematics is a social compact is aggrandizing the role of the axiom, and minimizing the rest of mathematics. It is certainly the case that axioms are in fact a "social compact" in the sense that if we cannot agree that a set of given axioms are true without proof, then we can prove nothing. But the goal of axioms is to make that compact as narrow and clear as possible.
The brief discussion of Godel's incompleteness theorem elides the fundamental nuance that incompleteness has only been demonstrated in the context of self reference. There is a longer and better discussion of how this relates to logic, science, and consciousness in Hofstadter's seminal work "Godel, Escher, Bach"
That said, software of all kinds (including machine learning) does make the world more interesting and exciting, so happy to see more investment.
Tcl's extensibility led to expect, which was very useful for automating scripting over telnet.
The ability of python to integrate with C/C++ code went a long way to making it a long term viable platform. If you needed scripting you could code in regular python. If you needed advanced control of hardware in your scripts, you could write a python extension in C/C++ to gain access to that hardware. If you needed high performance, or high parallelism, you could likewise create an extension to solve those problems.
In this way Python was the best of both worlds. Elegant scripting which could be combined with blazing performance and low level hardware interfaces. This aspect of the language allowed it to have a wide footprint (as opposed to just the browser) and to leverage legacy libraries effectively - e.g. BLAS.
I personally did crazy stuff like: "embed a python interpreter in a C program, to use python scripting within the program" back in like 1999.