Simon原本认为vibe coding和agentic engineering有明确界限，前者不关注代码质量，后者则是专业软件工程师使用工具的方式。

Simon表达了对vibe coding和agentic engineering边界模糊的担忧，这让他感到不安。

作者原本认为vibe coding和agentic engineering有明确界限，但现在发现两者界限正在模糊，这让他感到不安。

【洞察】「LLM 加速了错误的部分」——这句话点破了 AI 编程工具的根本问题：它们加速了代码的「生成」（原本不是瓶颈），却无法加速代码的「理解、审查和维护」（真正的瓶颈）。与 a16z 报告的「10-20x 生产力提升」数据对照：生产力的提升是真实的，但被提升的维度是否是最应该被提升的维度，是一个完全不同的问题。

✉️【洞察·监督悖论】这是本周关于 AI 编程最深刻的一句话：越依赖 AI，越失去监督 AI 的能力。这是一个隐性的技能退化循环，与肌肉萎缩类似——不用则废。与 Uncle Bob「传统编程已终结」的乐观叙事正面交锋：如果开发者失去了理解代码的能力，他们还能做什么来保证 AI 生成代码的质量？

在当今AI辅助编程盛行的时代，大多数人认为利用AI工具加速开发是理所当然的，但MeshCore团队坚持所有代码都是手工编写，这挑战了软件开发行业的效率优先共识。

大多数人认为AI在复杂编程任务中仍需要人类监督和干预，但作者认为GPT-5.5已经能在复杂的命令行工作流中达到82.7%的准确率，这挑战了'AI编程助手仍处于辅助阶段'的共识，暗示AI可能在某些编程领域已经接近或达到专业人类水平。

在单次编码任务中的卓越表现和对自身局限性的诚实认知，展示了AI在准确性和自我意识上的双重进步，这种对自身能力的准确评估对于构建可靠的AI系统至关重要。

13%的性能提升在AI领域是显著的飞跃，特别是解决了前代模型完全无法处理的任务，这表明AI能力的非线性发展可能已经到来，而非简单的线性进步。

这是一个惊人的发现，表明AI已经能够完成通常需要人类工程师数周时间才能完成的复杂编程任务。这不仅挑战了我们对AI当前能力的认知，也暗示了软件工程领域可能即将发生重大变革。这种级别的自主编程能力远超当前主流AI编程助手的表现。

令人惊讶的是，在将UI设计稿还原成代码的测试中，GLM-5V-Turbo的得分(94.8)显著领先于Claude Opus 4.6(77.3)，这表明它在视觉编码领域有着惊人的优势，几乎领先了17个百分点，这种差距在AI模型比较中是非常罕见的。

令人惊讶的是：编程已成为AI在企业中最主要的应用场景，其规模远超其他用例近一个数量级。工程师使用AI工具可以将生产力提高10-20倍，这一惊人的效率提升解释了为什么企业愿意如此迅速地采用AI编程工具，也颠覆了人们对软件开发工作流程的传统认知。

「比第二名多了将近一个数量级」——这句话说明企业 AI 市场目前几乎等同于「编程 AI 市场」。Support、Search 加在一起，可能也远不及 Coding 一项。这个数据的深远含义是：当前所有关于「AI 正在改变哪些行业」的讨论，其实主要在说软件工程这一个领域。其他行业的「革命」大多还停留在叙事层面，而非收入层面。

Estaríamos hablando de un estilo gramatical para escribir en MD? ¿Es similar a cuando se enseña a los programadores buenas prácticas al escribir código para su posterior actualización?

Peter Naur, Programming as Theory Building 1985 https://doi.org/10.1016/0165-6074(85)90032-8

Programming as theory building 1985 in Zotero

blogger Fabrizio Ferri Benedetti on their 4 modes of using AI in technical writing. - watercooler conversations, to get code explained - text suggestions while writing/coding (esp for repeating patterns in your work - providing context / constraints / intent to generate first drafts, restructure content, or boilerplate commentary etc. - a robotic assembly line, to do checks, tests and rewrites. MCP/skills involved.

Not either/or but switching between modes

async coding agents: prompt and forget

non-vendor related coding agents. - [ ] which of these can I run locally? / integrate into VS Code

list of command line coding agents by major vendors

author def of coding agents

suggested ollama models for code generation, 4 out of 5 are Chinese, one other from OpenAI

CodeGPT and this blog are run by Judini Inc, a Miami based US corporation

Another Qwen model, without the focus on visual inputs. Alibaba. Listed in ollama

Qwen models are by Alibaba. The VL versions are for visual inputs to generating code. Listed in ollama

DeepSeek, Chinese model. Listed in ollama

GLM is a Chinese model. I don't see it listed in Ollama though.

oh neat, so basically the NewType thing is a way to be more explicit about what a function is expecting, without needing to spend loads of time defining a dataclass and so on - it's a bit like annotating an existing type like a string, in a way that subsequent functions fo look for

We're at the point in humanity's development of computing infrastructure where the source code for program texts (e.g. a module definition) should be rich text and not just ASCII/UTF-8.

Forget that I said "rich text" for a moment and pretend that I was just narrowly talking about the inclusion of, say, graphical diagrams in source code comments.

Could we do this today? Answer: yes.

"Sure, you could define a format, but what should it look like? You're going to have to deal with lots of competing proposals for how to actually encode those documents, right?" Answer: no, not really. We have a ubiquitous, widely supported format that is capable of encoding this and more: HTML.

Now consider what else we could do with that power. Consider a TypeScript alternative that works not by inserting inline type annotations into the program text, but instead by encoding the type of a given identifier via the HTML class attribute.

Now consider program parametrization where a module includes multiple options for the way that you use it, and you configure it as the programmer by opening up the module definition in your program editor, gesturing at the thing it is that you want to concretely specify, selecting one of those options, and have the program text for the module react accordingly—without erasing or severing the mechanism for configuration, so if another programmer wants to change the module parameters to satisfy some future need—or lift that module from your source tree and use it in another one for a completely different program—then they can reconfigure it with the same mechanism that you used.

Voici un sommaire de la vidéo avec des indications temporelles basées sur le déroulement du contenu :

• Introduction (Début de la vidéo) : L'introduction est faite par Elena, la fondatrice de Toadhouse Games. Elle explique que ce tutoriel est conçu pour les débutants qui n'ont aucune connaissance en codage et que les premières vidéos seront gratuites sur YouTube. Elle présente Ren'Py comme un moteur de roman visuel utilisé par des milliers de créateurs.

• Qu'est-ce que Ren'Py ? (Environ 0:00 - 1:00) : Ren'Py est un moteur pour créer des romans visuels et de la fiction interactive. Bien qu'il fonctionne avec du code Python, il n'est pas nécessaire de savoir coder pour l'utiliser. Le logiciel fournit tout ce dont vous avez besoin, y compris des éditeurs de texte.

• Téléchargement de Ren'Py (Environ 1:00 - 2:00) : Il faut se rendre sur ri.org et cliquer sur le bouton de téléchargement. Différentes versions sont disponibles pour Windows, Mac, Linux, Android et iOS. Une fois le fichier téléchargé, il faut l'exécuter et extraire les fichiers dans le dossier de votre choix.

• Ouverture et présentation du lanceur Ren'Py (Environ 2:00 - 4:00) : Dans le dossier extrait, double-cliquez sur l'application Ren'Py (l'icône avec un anime) pour ouvrir le lanceur. Le lanceur affiche les projets ouverts (tutoriel et question par défaut) et les fichiers associés à chaque projet. Sur la droite, l'option "script" permet d'accéder aux fichiers de code, qui peuvent être édités dans un éditeur de texte comme Atom. Ren'Py peut télécharger et installer Atom pour vous.

• Exploration des fichiers du projet (Environ 4:00 - 5:00) : Le dossier "game" contient tous les fichiers du jeu (audio, musique, images, etc.). Un raccourci vers le dossier "images" est également disponible. Le fichier "script" contient le code du jeu, y compris les dialogues, les transitions, la musique et les scènes. Les options et les écrans (screens) permettent de personnaliser l'apparence du jeu.

• Construction et distribution du jeu (Environ 5:00 - 5:30) : L'option "build distributions" permet de créer une version jouable de votre jeu pour la partager avec d'autres sur différentes plateformes comme PC, Linux, Mac, itch.io ou Steam.

• Exercice pratique avec le projet "The Question" (Environ 5:30 - 8:00) : Il est recommandé de sélectionner le projet "the question" et de lancer le projet pour jouer au jeu. Ensuite, ouvrez le script du projet "the question". L'exercice consiste à jouer au jeu tout en regardant le code correspondant dans l'éditeur de texte. Cela permet de comprendre comment le code contrôle le déroulement du jeu (musique, scènes, dialogues, choix). Il est possible de faire de petites modifications dans le script et de recharger le jeu pour voir les changements.

• Présentation de Scrivener (Environ 8:00 - 9:00) : Scrivener est un logiciel optionnel qui peut être utilisé pour écrire le dialogue et organiser le contenu de votre roman visuel. Un modèle Ren'Py pour Scrivener créé par Toadhouse Games est disponible. Scrivener propose des conseils d'écriture de base et des modèles pour les profils de personnages et le code Ren'Py.

• Conclusion (Environ 9:00 - Fin de la vidéo) : Elena encourage les spectateurs à commencer à expérimenter avec Ren'Py en modifiant le projet "the question". Des tutoriels plus avancés sur les "flags" et les choix seront proposés ultérieurement. Des ressources d'aide sont disponibles sur Twitter, par e-mail (teamtoadhouse@gmail.com), sur les subreddits et les forums Ren'Py, ainsi que sur le Discord de Toadhouse Games.

Voici un sommaire avec des horodatages (timestamps) de la vidéo, mettant en évidence les points les plus importants en gras et en français :

• [0:00] Introduction et bienvenue à la chaîne Toadhouse par une artiste invitée, Thunderbird Paints, qui est l'artiste principale et directrice artistique de Toadhouse Games. Elle prévoit de parler de la conception des environnements, des personnages et potentiellement de l'interface utilisateur pour les romans visuels.
• [1:00] Début de la discussion sur la conception des personnages et des environnements pour les romans visuels, en commençant par les personnages car ils sont la base d'un roman visuel.
• [2:00] L'importance d'avoir une idée du scénario avant de concevoir les personnages. L'artiste lance l'idée de créer un roman visuel fictif avec des thèmes rétro, comme un décor de foire Renaissance ou de western cowboy.
• [3:00] Choix d'un thème de roman visuel sur le thème de Donjons et Dragons (D&D). Discussion sur le personnage principal : statique ou adaptable (avec un générateur de personnages). Le chat vote pour un personnage principal spécifique.
• [3:00] Détails du personnage principal : un barde avec un accent texan, non binaire. Discussion sur la race du personnage (humain, demi-orc, demi-elfe).
• [4:00] Application de la discussion sur la conception des personnages concernant les scènes spéciales (CG) et l'interaction avec d'autres personnages, en tenant compte de l'esthétique et des constructeurs de personnages.
• [5:00] Principes de base pour dessiner un personnage, en commençant généralement par une illustration de référence (turnaround). Importance de considérer l'esthétique de base et le potentiel de cosplay.
• [6:00] Début du croquis d'un personnage demi-orc non binaire, en se concentrant sur la forme générale et les épaules. Discussion sur les méthodes de coloration (traits et remplissage ou une seule couche).
• [7:00] Continuation du croquis de référence (turnaround), en veillant à l'alignement des différentes parties du corps. Utilisation de guides pour la hauteur et la variance des types de corps et des formes.
• [8:00] Esquisse des traits du visage, en commençant par le nez d'orc. Importance de l'hydratation (mention du robot à eau). Discussion sur l'influence d'un chapeau de cowboy sur la coiffure et l'utilisation de références.
• [9:00] Ajout de détails à la tenue, comme un gilet. Discussion sur le fait que les romans visuels ne doivent pas nécessairement être romantiques et qu'ils peuvent inclure des mini-jeux et des scénarios non linéaires.
• [10:00] Poursuite de l'ajout de détails à la tenue (jambières, éperons). Mention de romans visuels comme Persona. Pause thé avec l'apparition des chats.
• [11:00] L'inspiration du jour liée à la citation du sachet de thé. Continuation du dessin des bottes de cowboy. Discussion sur la quantité d'art de personnage typiquement visible dans un roman visuel (buste ou taille).
• [12:00] Importance d'avoir des sprites de corps entier pour les zooms et les effets, ainsi que pour les scènes spéciales. Ajout d'éléments à la tenue (sac, bretelles).
• [13:00] Finalisation de la silhouette et ajout d'une guitare. Réglage de la forme du chapeau. Début de la stylisation de la tenue.
• [13:00] Séparation des calques pour le croquis de face et de dos. Ajout d'une ceinture. Le chat approuve le design.
• [14:00] Début de la coloration du personnage, en utilisant une seule couche pour la plupart de l'illustration conceptuelle. Discussion sur les couleurs de peau des tieffelins dans D&D.
• [15:00] Discussion sur la personnalisation des personnages dans les jeux et la création d'éléments de personnalisation.
• [15:00] Retour à la définition des traits du visage, en se concentrant sur la forme du visage, les expressions et les couleurs.
• [16:00] Informations généralement fournies lors de la création d'un design de personnage (personnalité, historique, apparence physique, couleur préférée). Le rôle de l'artiste dans la traduction de la personnalité en esthétique visuelle.
• [17:00] Fin de la coloration de la tenue principale. Transition vers la conception des environnements. Importance de la posture pendant le dessin et suggestion d'étirements.
• [17:00] Couleur de la guitare inspirée de l'ancienne guitare de l'artiste. Couleur de la ceinture.
• [18:00] Couleur du bord du chapeau et des bottes. Choix de la couleur du pantalon pour créer un schéma de couleurs cohérent. Discussion sur la modification des couleurs.
• [19:00] Célébration des abonnements offerts à la chaîne. Ajout d'un détail de chemise dépassant.
• [20:00] Discussion sur la création de sprites de personnages et l'importance des expressions faciales. Le nombre d'expressions nécessaires (généralement six ou sept).
• [21:00] Croquis rapide d'une guitare. L'idée de la conception prime sur le détail parfait.
• [21:00] Ajout rapide d'orteils. L'artiste utilise le même pinceau pour la plupart du concept.
• [22:00] Ajout de boutons. Idée d'utiliser l'asymétrie dans la conception des tenues pour montrer qu'un personnage est légèrement déséquilibré.
• [23:00] Exemples de modifications de la tenue pour créer différents aspects (manches, capes, gants).
• [23:00] Retour à la conception de base et discussion sur les expressions faciales (colère, tristesse).
• [24:00] Question sur le stockage des expressions faciales et des poses corporelles. L'artiste montre des exemples de son travail sur "Call Me Sarah" et "Good Looking Home Cooking", où les corps et les expressions sont généralement conservés séparément pour permettre des changements dans le langage corporel.
• [26:00] Conseils pour accélérer la conception des personnages pour un délai court (nombre d'expressions limité, poses simples, réutilisation d'éléments).
• [27:00] Démonstration rapide de changement d'expressions faciales en modifiant des éléments comme les yeux, la bouche et les sourcils, tout en conservant le même corps.
• [28:00] Transition vers la conception des environnements après une courte pause.
• [29:00] Introduction à la conception des environnements, perspective et outils (pinceaux de perspective). Importance de placer la ligne d'horizon au milieu pour un roman visuel.
• [30:00] Croquis rapide d'un coin de rue médiéval, en utilisant des formes simples pour les bâtiments. Utilisation de la touche Shift pour tracer des lignes droites.
• [31:00] Ajout d'éléments comme des arbres et un magasin général. Discussion sur l'alignement des personnages et des arrière-plans pour qu'ils s'intègrent mieux.
• [32:00] Utilisation de références photographiques pour la taille des bâtiments par rapport aux personnages (exemple d'Hershey Park). Ajustement de la taille et de l'emplacement des éléments d'arrière-plan.
• [33:00] Zoom sur une partie de l'esquisse d'arrière-plan pour montrer un arrière-plan potentiel pour un roman visuel. Début du blocage des couleurs de l'environnement.
• [34:00] Poursuite du blocage des couleurs (bâtiments, arbres). Importance de créer des calques séparés pour les éléments d'arrière-plan pour faciliter les modifications.
• [35:00] Incident technique avec le stylet de la tablette. Reprise et continuation du blocage des couleurs.
• [36:00] Présentation d'exemples d'environnements précédemment créés et promotion de l'événement annuel "Environment-tober" pour la pratique des environnements.
• [37:00] Retour à l'esquisse de l'environnement, suppression des lignes de perspective et début de l'ajout de détails et de considérations sur la source de lumière.
• [38:00] Démonstration de la création de différentes ambiances lumineuses (crépuscule, matin) en dupliquant le calque de couleurs de base et en utilisant des modes de fusion et des couleurs différents.
• [39:00] Importance des ombres pour les bâtiments et le paysage. Démonstration rapide de la création d'une scène de nuit avec des étoiles.
• [40:00] Finalisation de la démonstration de la création d'une scène de nuit. Remarques de clôture, excuses pour ne pas avoir abordé l'interface utilisateur, invitation à poser des questions sur Discord.
• [41:00] Message de fin et salutations.

Welcome! the entire website is commented in hypothesis you can add your comments here notes, revision this is a live page

https://web.archive.org/web/20250215071640/https://thathtml.blog/2025/02/we-need-to-talk-about-anti-web-coding-assistants/

Blogger Jared White warns that LLMs coding output is as bland as its prose output and seem biased to some specific frameworks. #slop Horrifying example of people waiting on AI to catch-up with new versions of framework. That is really bad.

Casey, Robert S., James W. Perry, Madeline M. Berry, and Allen Kent. Punched Cards: Their Applications To Science And Industry. 2nd ed. 1951. Reprint, New York: Reinhold Publishing Corporation, 1958. http://archive.org/details/PunchedCardsTheirApplicationsToScienceAndIndustry.

the exporter makes different API calls

so there is room for optimization

I'd be happy to take a further look if I get faced with metrics supporting the high CPU usage

yes! numbers. of course. let me put that "somewhere" on my todo list...

for - semantic folding - semantic fingerprint - cortical.io - numenta - sparse coding - Francisco Webber - symmathesetic fingerprint

summary - In this informative interview, Francisco Webber, a principal cofounder of Cortical.io, discusses how the company's core technology, semantic folding and semantic fingerprints of words is unique and differs from the usual AI large language models. - Cortical I/O's approach is a biomimicry approach that is based on representing words in the way that brain operates. - It employs a word-to-geometry mapping implemented using Numenta's sparse coding technique. - This approach allows Cortical to train using very small training data sets of 100 gigabytes of data, which takes a few hours to train - many orders of magnitudes smaller than normal AI training data sets.

for - key insight - failure of the gene coding uni-causal model - key insight - failure of genetic determinism

for - comparison - genome coding to computer program

Elegant suggestion: write comments in code that are clearly outdated when the surrounding code changes.

For anyone interested in this I would also recommend anything regarding etoys https://www.youtube.com/watch?v=prIwpKL57dMhttp://www.squeakland.org/

Interesting need to look at this , It would be a good execercise.

thats how it begins

A thought leader in creative coding.

? Make it facing?

? what is meant by proper direction?

^ Keeping the Rigidbody's y velocity for jumping and falling

^ We can update a Rigidbody's velocity

Manipulating object's scale

? not recommended to use vector3 for player movement

Changing the transform of one object to another's

-- Vector3 allows us to change the individual axes

? What is Rewired?

Gebre, M. S., Rauch, S., Roth, N., Yu, J., Chandrashekar, A., Mercado, N. B., He, X., Liu, J., McMahan, K., Martinot, A., Martinez, D. R., Giffin, T., Hope, D., Patel, S., Sellers, D., Sanborn, O., Barrett, J., Liu, X., Cole, A. C., … Barouch, D. H. (2021). Optimization of Non-Coding Regions for a Non-Modified mRNA COVID-19 Vaccine. Nature, 1–8. https://doi.org/10.1038/s41586-021-04231-6

I think this phrase describing the Colonel will be important throughout the novel. I do we write code to trace this collocation "wicked Colonel"?

I think that "superstition" is a keyword in The Moonstone. How do I write code to track each sentence/phrase in which "superstition" appears?

Lehnen, N., Glasauer, S., Schröder, L., Regnath, F., Biersack, K., Bergh, O. V. den, & Werder, D. von. (2022). Post-COVID symptoms in the absence of organic deficit—Lessons from diseases we know. PsyArXiv. https://doi.org/10.31234/osf.io/yqar2

e.g. C++, C

One danger of abstraction; in unusual situations, the simplified model may provide incorrect predictions. For this reason, computer programming practitioners should have some understanding of how computers operate as well as detailed knowledge of the programming language.

Programming for Engineers – David Johnson

source - https://www.youtube.com/watch?v=dPb1bg1mVLg

Intro: * Project-based approach * Core fundamentals * Not a tutorial

See the companion modules in the link: https://www.engineeringwithutsav.com/roadmaps

...also recommendations for: * Data structure and algo books * Building good coding habits * Free resources

What is an assembler language? https://en.itpedia.nl/2019/11/11/wat-is-een-assembler-taal/ An #assembler_language is a low-level programming_language designed for a specific processor type. We can produce Assembler by compiling #source_code from a high-level programming language (such as C / C ++). But we can also write #programs in this language ourselves. In turn, we can convert Assembler_code into machine_code using an assembler.

See my Coding Challenges.

Lean Canvas

For the builders collective, I created some tools that are open source and useful for design and social architecture. Other projects are coding challenges to experiment with what is possible on the web.

This experiment is based on the Lean Canvas, based on the Business Model Canvas from the book Business Model Generation.

Type in the grey box at the top of the page. Click or tap in the boxes to add the text as a box in each section of the Lean Canvas. Click on the box to delete.

There is no save functionality, so be sure to take a screenshot. Or roll your own by using the code on Codepen and GitHub.

Resuena con lo que hemos dicho en la comunidad de Grafoscopio, de no similar el computador en la cabeza, de ahí la importacia del live coding y los metasistemas, programados en sí mismos.

Alan Jacobs eschews the admonishment that everyone should learn to code and posits a more basic early literacy stepping-stone to coding: learning some basic preliminaries of self-hosting. This is likely much easier for most people and could build a better runway for those who would like to learn to code later on.

I've seen this sentiment before as well.This is also well attested in writing code too.

Writing for the public keeps you honest and makes one put more work into the product than they otherwise might.

Peer, L., Orr, L., & Coppock, A. (2020). Active Maintenance: A Proposal for the Long-term Computational Reproducibility of Scientific Results. SocArXiv. https://doi.org/10.31235/osf.io/8jwhk

What do you do with your API key? "WHERE DO I PUT IT?!?" https://youtu.be/ecT42O6I_WI?t=338

Also, suggests to get a JSON formatter browser extension. e.g.: "JSON Formatter" from the Chrome Web Store Here's a good one: https://chrome.google.com/webstore/detail/json-viewer/gbmdgpbipfallnflgajpaliibnhdgobh/

Call for Code (2020) Accept the 2020 Call for Code Global Challenge. Retrieved from:https://callforcode.org/challenge/?utm_content=buffere99fc&utm_medium=social&utm_source=twitter.com&utm_campaign=buffer

Perkel. J. M., (2020). Challenge to scientists: does your ten-year-old code still run? Nature. Retrieved from: https://www.nature.com/articles/d41586-020-02462-7?utm_source=twt_nnc&utm_medium=social&utm_campaign=naturenews&sf237106326=1

I was going through my Firefox bookmarks and I found article. I had read this article two years back and had commented that I found it to be useful. I read it back in May 2018. As of now, November 2020, my programming skills are still novice-level. I haven't implemented the ideas or followed suggestions given here.

It has been 2 years and 5 months since I found this article to be relevant and it baffles me that I haven't taken action by making use of the knowledge given in this article. Two long years flew by. I guess reviewing my bookmarks is something that I will do more often.

The article was posted on May 23, 2018 and I had stumbled on it the next day itself, i.e., May 24, 2018. This gets me thinking that we could finds solutions for problems(latest ones in this case) once we identify it, articulate it, hit the search button and just read stuff. I could presume that what happened next was that I misunderstood "finding a solution" to "realizing the solution", and perhaps became complacent or maybe there were more problems that didn't come to my awareness to identify and further find solutions. I'm not quite sure. Should I have identified my problems and googled more so that I could have learned C and C++ sooner?

I wonder what held me back from taking action to accomplish and master something that usually takes not more that 5-6 months maximum.

On learning programming

• Master one first programming language first, before moving to the next.
• Learn at a slow for the first two programming languages. This is important for beginners
• Practising coding is more important than watching tutorials or reading books. You learn more by practising than by reading or watching videos.
• Apart from tutorials, immitating open source projects is very important
• Read others code and immitate it. You'll be surprised at how fast you're learning.
• Make use of StackOverflow, Quora and programming subreddits.Ask questions there. Interact more.
• Practice more. Write code from time to time. Debugging skills imporove with more coding practice.
• Test your skills with quizzes, challenges and competitive programming

Practice programming challenges with HackerEarth and then move to TopCoder.

Project Euler emphasises on programming challenges that involve problem solving and critical thinking skills.

You'll learn more when you read others' code and immitate it. CodeChef provides you access to learn from others' code.

What is Mercurial?

what are scalar values in JavaScript?

It would be great to have a bi-directional link here to a reputable source.

That brings up the questions of how you define reputation...

I digress.

The process of coding is transparent and detailed. The explanations for the first coding dimension of observation, rewrite, rewrite with explanation, the second dimension as content versus mechanics, and the third as the length of the comment (more than or less than 10 words)

Codecheckers/covid-uk. (2020). [R]. CODECHECK. https://github.com/codecheckers/covid-uk (Original work published 2020)

r/BehSciMeta—Comment by u/nick_chater on ”Programming errors and their implications”. (n.d.). Reddit. Retrieved June 1, 2020, from https://www.reddit.com/r/BehSciMeta/comments/gsowog/programming_errors_and_their_implications/fsi76l7

r/BehSciMeta—No appeasement of bad faith actors. (n.d.). Reddit. Retrieved June 2, 2020, from https://www.reddit.com/r/BehSciMeta/comments/gv0y99/no_appeasement_of_bad_faith_actors/

So these pseudopopulations were random agglomerates of single neurons that were recorded, so many fits for random groups, and the best were kept?

Essentially this is kind of like constructing dissimilarity matrices over large groups of voxels?

Bull, P. (2020, May 10). Why you can ignore reviews of scientific code by commercial software developers. Lumps “n” Bumps. https://philbull.wordpress.com/2020/05/10/why-you-can-ignore-reviews-of-scientific-code-by-commercial-software-developers/

Is the “science” behind the lockdown any good? (n.d.). Financial Times. Retrieved June 2, 2020, from http://ftalphaville.ft.com/2020/05/21/1590091709000/It-s-all-very-well--following-the-science---but-is-the-science-any-good--/

🔥Kareem Carr🔥 on Twitter: “I want to talk about bugs in statistical analyses. I think many data analysts worry unnecessarily about this. I do think it’s important to put a good faith effort into avoiding bugs, but I know data analysts that live in terror of hearing there’s a bug in published work. 1/6” / Twitter. (n.d.). Twitter. Retrieved May 30, 2020, from https://twitter.com/kareem_carr/status/1266029701392412673

This made me chuckle--both because I am living in a pseudocoding space myself, so I identify with the self-deprecating humor, and because of the riff on "I, Robot"

A compiler: source code to object code

A high-level code processor - interpreter

The programming skill

The definition of an algorithm

The importance of problem solving for CSs

Computer scientists combine features of mathematicians, engineers and natural scientists

This is like a coding schema!

The setup of a website is important to understand. It helps to make the content more approachable and understandable.

I'm not really sure I agree with this. Regardless of whether Singularity eventually comes around or not, software will evolve. We have seen whole languages fall out of usage in the past, including Fortran, COBOL, ALGOL, etc. Developers will always be looking to get more efficient, and our current languages will either get abandoned or improved. New languages will come up and become the new standard. If anything, the future seems to be far more bleak for programmers/developers in the years after Singularity, rather than in the years leading upto it - after all, with the prevalence of docile, conscious machines,most of the work programmers do, everything from bug-fixing to data-analytics, would be done more quickly, cheaply and efficiently by the machines. In other words, in the world of singularity, programmers as we know them would no longer exist.

Rasberry Pi y otros sistemas de Live Coding, introducirían nuevas maneras de hacer música.

Tanto Leo como Grafoscopio tienen limitaciones (y propósitos distintos). Sin embargo, en el caso de Grafoscopio, siento que puedo englobar y superar dichas limitaciones más fácilmente, no tanto porque lo hice desde el comienzo, sino por el entorno de live coding que me permite explorar y modificar el entorno en caliente.

Area 2 of educational focus

Time taken to code for scoping study

Time taken to code records

Step 2: Grabs the data from the URL...