You could scaffold a project, and it runs, and then you check back to see what it recommends.
This would help so much with understanding concepts and merging fields. It is way too common for different fields to independently "discover" some concept and be completely ignorant of all the work that has been done on that concept by some other field.
It reminds me of how they hit a limit in the Android VM because their code had so many classes, and decided to work around it instead of reflecting (no pun intended) on how they ended up with so much code in the first place: https://news.ycombinator.com/item?id=5321634
How hard would be?
Mention coding by voice and someone will explain how they can’t imagine not using a keyboard, or they bring up the open office problem.
Considering the limited scope, it’s probably just a matter of the proper editor integration.
Intellisense or shortcuts do this up to a level, but the current big IDEs are limited. Maybe some editor with the concept of VIM with a separate command and edit mode would be more fit to work like that.
- Ubiquitous frictionless headphones with built in mics like the AirPods.
- More demand and access to remote working where people are alone at home.
Currently for most languages, we have: "type productions of a particular syntax and try really-really-hard to color between the lines, and subject yourself to the chinese-water-torture of syntax errors till YOU get better at it".
Why not invert that, whether via mouse input, a visual (as in literally, visual, not microsoft-visual) connection, or a text editor that simply doesn't let you type invalid productions. Like Intellisense, but taken to the function or block level. You cannot save the file or even leave insert mode until the code compiles. Or even better, you cannot even temporarily input invalid syntax. From the first keystroke, it inserts a variable declaration, click/type up or down to choose a function call, conrol structure, etc.
Some vim-like integration would go as follows:
* <space>+F outputs a function called func1, auto-highlighted for you to rename (or accept default).
* <space>+R on the func name lets you set its return type
* <space>+A for args,
* <space>+B to edit the function body
At no point would you be allowed to input non-compiling syntax. Things like indentation would be non-issues, set uniformly by defaults.
Live demo (try Django out):
Machine code instructions designed by hand are not necessarily the best fit for the code we actually generate. Similarly, might our approach to language design lack pragmatic insight as to which constructs should be favoured, adopted, simplified etc?
“Data-driven language design”.
Separately, for very micro-level idiomatic things, like use of a certain data type operation or efficient constructor patterns, I need to search by natural language descriptions of the subtle differences between options. This is what makes Stack Overflow so helpful, the accompanying natural language description of intentionality or special cases, even if the code that is found isn’t precisely what’s needed, it demonstrates directionally what to do.
This tool seems like yet another example of trying to force machine learning solutions to problems nobody actually has.
Considering the idea that I’d need to integrate this into my coding environment, I’ll say No Thanks!
You're entirely right, but if you're in an incredibly huge monorepo like Facebook, this information literally doesn't exist; that's part of the problem that Aroma is trying to solve - "how can we show people the Facebook App Way To Do That Thing, even if That Thing doesn't have current documentation"
(Disclaimer: I worked on the coding environment UX for Aroma)
I'd argue Aroma solves a different problem in that it surfaces more idiomatic patterns based on the code you already have. This also can be important especially in production environment, when you need to do things "the right way".
An Information Foraging Theory Perspective on Tools for Debugging, Refactoring, and Reuse Tasks https://dl.acm.org/citation.cfm?id=2430551
The paper applies IFT to software engineering, but IFT has also been applied to navigating websites or even physical offices. Use Scholar.Google.com to find a PDF of the paper if you don't have ACM access.
Can u point out any work on refactoring existing code for reduced code complexity?
Obtaining same (non)functional behavior using less code.
EDIT: i will read the CodeDeviant paper
CodeDeviant itself is a tool to help programmers perform manual refactorings without unit tests (in a visual programming language), so it may not be helpful for you :)
A quick search through Facebook's profile on Github turned up nothing.
I can learn from a paper, but I learn much faster from an example!
however when I try to install it on Mac OSX, I get
Couldn't find a compatible version of Visual Studio Intellicode - Preview with this version of Code
(Thinking specifically of the "binary search in the Java API was broken for X decades" one with the integer overflow.)