1,252 Matching Annotations
  1. Sep 2024
    1. I would say that a system that allowed other metathings to be done in the ordinary course of programming (like changing what inheritance means, or what is an instance) is a bad design.
    1. In practice, forks and threads are at odds with each other. If you try to fork while there are active threads, you will very likely run into bugs. Even if you didn't create the thread, some other library might have, so it can be very tricky in practice.
    1. In comparison, Perl/Python/Javascript, which also have the latter property, have other false-like values (0 and empty string), which make || differ from a null-coalescing operator in many more cases (numbers and strings being two of the most frequently used data types). This is what led Perl/Python/Javascript to add a separate operator while Ruby hasn't.
    2. Examples by languages
    1. If you'd like another method to do the waiting for you, e.g. Kernel.select, you can use Timers::Group#wait_interval to obtain the amount of time to wait. When a timeout is encountered, you can fire all pending timers with Timers::Group#fire

      This is another way of achieving concurrency (progress made while waiting for other things) besides wrapping the timer's sleep in a separate thread like https://github.com/rubyworks/facets/blob/main/lib/standard/facets/timer.rb does.

  2. Aug 2024
  3. Jul 2024
    1. how do I get to this number between 0 and 1? Well, by simply reading on in the spec. There is some some pseudo code, which is easily translatable to Javascript (which I'm doing here in form of a literate program
    1. We decided that we would like to see better documented code included within web pages for convenient browsing. The motivation behind this peculiar aim is to be able to include high quality documentation alongside working code, hopefully making it easier for programmers to produce more maintainable, readable programs.
    1. Say goodbye to the headaches of setting up Python locally. No more installations or configurations, you can execute Python code right in your web browser. Just input your code, hit RUN, and watch the magic happen! Compile, run, and share Python code online with our powerful integrated Python development environment (IDE). Want to show off your work? Use the SHARE option to make your code accessible to anyone, anywhere.

      One of the best python compilers if you're a new dev and dont want to install Python locally.

  4. Jun 2024
    1. This approach of interleaving documentation and source code is called literate programming and was first proposed by Donald Knuth in 1984. He argued that all code should be written in these linear, readable documents. See Chris Granger's Eve project for a beautiful example of mixing prose and code.
    1. Tutorial Hell

      What Is Tutorial Hell - Related Pages

      • Learning is a Never-Ending Process - <q>Continuous learning helps your growth, problem-solving, confidence. Securing your future in a changing world. See why learning is a never-ending process.</q>
      • Tutorial Hell (Programming) - <q>In Tutorial Hell (Programming), learners get too dependent on tutorials. For programs, graphics, and related skills. Learn to beat Programmer's Tutorial Hell.</q>
      • Getting started with Hive app development - <q>… I don't recommend spending too much time doing tutorials as you will end up in tutorial hell where you just do tutorials but have no idea …</q>
      • Taking The Wheel - <q>… tutorial hell by opting to watch a full tutorial or reading the entire blog post. I've found that after I've done so, I feel sad with the knowledge that I …</q>
      • Learning web2 for web3 - <q>Simply because I was trapped in a tutorial hell, I don't think I have ever been so confused. I did all these for one year without developing something …</q>
    2. Tutorial Hell

      "Tutorial Hell" is where individuals complete numerous tutorials without actually making meaningful progress. The key to escaping Tutorial Hell is to stop doing more tutorials and start building actual projects to solidify learning.

    3. Tutorial Hell
      • Who: The author (Coding Defined), professional developers, junior developers.
      • What: Facing Tutorial Hell - spending time watching tutorials without making meaningful progress.
      • Why: To discuss the negative impact of constantly watching tutorials without implementing what is learned.
      • How: The author discusses two concepts of Tutorial Hell

      • How it impacts learning

      • Why junior developers often fall into this trap

      Then, he provides tips on how to escape Tutorial Hell by:

      1. Focusing on building actual projects
      2. Implementing what is learned from tutorials.

      The author also shares personal experiences and examples to illustrate his points.

    1. Tutorial Hell

      Tutorial Hell (Programming) - Related Pages

      Learning is a Never-Ending Process - <q>Continuous learning helps your growth, problem-solving, confidence. Securing your future in a changing world. See why learning is a never-ending process.</q> What is Tutorial Hell? - <q>Are you asking "What is Tutorial Hell?" It is doing many tutorials without any meaningful progress. Escape Tutorial Hell and start building actual projects now.</q> Getting started with Hive app development - <q>… I don't recommend spending too much time doing tutorials as you will end up in tutorial hell where you just do tutorials but have no idea …</q> Taking The Wheel - <q>… tutorial hell by opting to watch a full tutorial or reading the entire blog post. I've found that after I've done so, I feel sad with the knowledge that I …</q> Learning web2 for web3 - <q>Simply because I was trapped in a tutorial hell, I don't think I have ever been so confused. I did all these for one year without developing something …</q>

    2. Tutorial Hell
      • Who: The author (the100) and learners in various fields such as programming, graphics designing, video editing, learning a new language, and cooking.
      • What: Discussing the concept of "tutorial hell" where learners become dependent on tutorials and struggle to apply their knowledge creatively.
      • Where: Online courses and tutorials found on platforms like YouTube, Udemy, and other websites.
      • Why: To caution learners against becoming too reliant on tutorials and encourage them to practice and apply their knowledge independently.
      • How: By emphasizing the importance of practicing, building projects, making mistakes, exploring documentation, asking for help, and using problem-solving skills to truly learn and improve in a skill. The author shares their personal experience of falling into tutorial hell and finding success through practical application and problem-solving. The advice given is to follow a tutorial thoroughly before starting to create projects independently.
    3. Tutorial Hell

      The post discusses the concept of "tutorial hell". Where learners become overly dependent on tutorials. Without applying their knowledge creatively. Using examples from programming, graphic design, and other skills. The author emphasizes the importance of practicing, making mistakes, and exploring on your own to truly learn and improve.

    1. Subtext is an ongoing experiment in radically simplified programming. It is radical in that I am willing to throw away everything we know about programming and start from scratch

      Programming , the very idea considered harmful. Can software be liberated from programming per se.

      https://cryptpad.fr/pad/#/3/pad/view/4ed3203237745f09bf6699a7e71750fe/

  5. Apr 2024
    1. Testrpc

      TestRPC Related Pages

      • Ganache CLI Install - <q>testRPC/ganache-cli testRPC/ganache-cli is a node.js Ethereum client for testing and development of the Smart… by technological.</q>
      • Ethereum TestRPC and Tester Client - <q>This provider automatically spins up the eth-testrpc server for you so that you can test your web3.py code against an in memory EVM. This provides lightning …</q>
      • Ethereum TestRPC vs. Geth - <q>Ethereum TestRPC vs. Geth explains that TestRPC is a client for testing and developing. While Geth is a full GO language client for connecting to the blockchain.</q>
      • TestRPC & Ethereum Smart Contracts - <q>… testrpc. For truffle test, testrpc or geth is required to be run explicitly. Else, you get the following error: $ truffle test Could not connect to your …</q>
    1. shrink-wrap on blender

      Blender Shrinkwrap Modifier Related Pages

      Here are some examples of pages about the Shrinkwrap modifier for Blender:

      • Get Good at Blender - <q>It's a tough one to make. So I go through the best practice with edge flow and pole placement. We also work with the shrinkwrap modifier. As a quick note, those …</q>
      • Blender Shrinkwrap Model - <q>… Blender Shrinkwrap Model Purpose. @buttonm wants to showcase their artwork. And share their creative process by modeling a concept car for …</q>
      • Blender Shrinkwrap & Mesh Deformer Modifiers - <q>For tighter clothes such as the croptop and the forgotten arm socks, shrinkwrap … Blender (I'll work that out when I start a …) #blender · #3d · #creativecoin.</q>
      • ProgBlog #1 - <q>… Currently, 1 is Krita, 2 is keys I use excessively in Blender … Blender only when sculpting and/or animating … shrinkwrap" (I'm not sure why it …</q>
      • June ProgBlog - <q>And fixed up anything that had gone slightly awry from the shrinkwrap which had mostly done its job at least. … Blender doesn't decide to lag massively (I'm not …</q>
    1. Installing testRPC/ganache-cli

      Ganache CLI Install Related Pages

    1. You can think of it as the following cycle:software engineer writes codeusers get new featuresmore users use your productscompany profits from productsSo code is just a tool to get profit.

      The core software development process

    2. 2) You will rarely get greenfield projects

      :)

    1. However, as we want to do perform the bisection automatically using as criterion ./calc.py 14 0, we run git bisect run ./calc.py 14 0

      git bisect run ./calc.py 14 0 ← example of running git bisect automatically. * If the commit is good, then the command should return 0; * If the commit is bad, then the command should return anything between 1 and 127, inclusive, except 125; * If it is not possible to tell if this commit is good or bad, then it need to be ignored, and the command should return 125.

    2. Git Bisect! It allows us to find the commit that broke something. Given a “good” commit (a commit that is not broken, created before the introduction of the bug), and a “bad” commit (a commit that certainly is broken), Git will perform a binary search until the broken commit is found.

      Git Bisect can be run manually or automatically

    3. What are the tools that comes on your mind when someone say “debug”? Let me guess: a memory leak detector (e.g. Valgrind); a profiler (e.g. GNU gprof); a function that stops your program and gives you a REPL (e.g. Python’s breakpoint and Ruby’s byebug); something that we call a “debugger” (like GDB, or something similar embedded on the IDEs); or even our old friend, the print function. So, in this text I’ll try to convince you to add Git to your debug toolbelt.

      6 differen debugging tools

    1. Additionally, students in the Codex group were more eager and excited to continue learning about programming, and felt much less stressed and discouraged during the training.

      Programming with LLM = less stress

    2. On code-authoring tasks, students in the Codex group had a significantly higher correctness score (80%) than the Baseline (44%), and overall finished the tasks significantly faster. However, on the code-modifying tasks, both groups performed similarly in terms of correctness, with the Codex group performing slightly better (66%) than the Baseline (58%).

      In a study, students who learned to code with AI made more progress during training sessions, had significantly higher correctness scores, and retained more of what they learned compared to students who didn't learn with AI.

  6. Mar 2024
    1. https://archive.org/details/run-de-1986-10/page/120/mode/2up

      "RUN – Unabhängiges Commodore Computermagazin", Ausgabe 10/Oktober 1986, which has a hexdump code listing of a C64 Zettelkasten

      ᔥ[Michael Gisiger[]] in mastodon: (@gisiger@nerdculture.de)

      Lust auf #Retrocomputing und #PKM mit einem #Zettelkasten? Bitte schön, in der Oktober-Ausgabe 1986 des #Commodore Magazins RUN findet sich ein Listing für den #C64 dazu. Viel Spass beim Abtippen 😅

      https://archive.org/details/run-de-1986-10/page/120/mode/2up

      See additional conversation at: https://www.reddit.com/r/c64/comments/1bg0ja1/does_anyone_have_the_zettelkasten_program_from/?utm_source=share&utm_medium=web2x&context=3

  7. Feb 2024
    1. Python 3

      The post discusses the confusion and challenges faced while learning to code in Python 3. Specifically related to functions and parameters. With a focus on solving tasks and understanding the distinctions between variables and parameters.

    2. Python 3
      • Who: The author of the post, Anmitsu.
      • What: Anmitsu's diary entry about learning to code in Python 3, specifically discussing confusions and problem-solving related to functions and parameters in the course material.
      • Why: Anmitsu is sharing their experiences and seeking advice and suggestions from others.
      • When: The post was made after Anmitsu encountered and solved some issues related to functions and parameters in Python 3.
      • How: Anmitsu discusses two specific tasks related to defining and calling functions, sharing their process of confusion, attempts at solving the problems, and the final solution they arrived at. They also mention seeking help from Code Academy for clarification.
  8. Jan 2024
    1. My First dApp

      The post discusses the author's experience and process of building their first dApp, a blockchain-based version of the game Battleship, using Ethereum, Solidity, and smart contracts.

    2. My First dApp
      • Who: The author, Tom
      • What: The author's experience building his first dApp, a game called Battleship, using Ethereum, solidity, and smart contracts.
      • Where: The author built the dApp using Truffle and deployed it on the Kovan testnet.
      • Why: The author wanted to learn how to make his own smart contracts and build dApps.
      • When: The author started the project a few months ago and wrote the post on PeakD.com to share his experience and help others.
      • How: The author:
        • Used Truffle as a framework for building dApps,
        • Ran a localhost node for testing using TestRPC,
        • Injected Web3 using the Metamask Chrome extension,
        • Used the Remix online editor for quick compilation and bug finding,
        • And wrote JavaScript tests using Truffle's testing framework. The author also built the UI using Angular 1 and played the game using Chrome and Metamask.
    1. Ethereum TestRPC vs Geth

      This post compares TestRPC and Geth, explaining that TestRPC is a client for testing and development, while Geth is a full client for connecting to the real Ethereum chain or starting a testnet server. It also mentions that successful tests in TestRPC can be transferred to Geth.

    2. Ethereum TestRPC vs Geth
      • What: The post explains that TestRPC is a Node.js based Ethereum client used for testing and development, while Geth is a full client in GO Language used to connect to the real chain or start a testnet server.
      • Where: The platforms mentioned in the post, TestRPC and Geth, are used in the Ethereum ecosystem.
      • Why: The purpose of the post is to compare the functionalities and uses of TestRPC and Geth.
      • When: The post does not provide specific information about the timing or date of the comparison.
      • How: The post explains that some successful tests conducted in TestRPC can be transferred to Geth.
    1. You should take care, however, to make sure that your individual objects can stand alone as much as possible. Tightly coupled objects are objects that rely so heavily on each other that removing or changing one will mean that you have to completely change another one - a real bummer.

      Isn't there a conflict between this principle and code reusability?

    1. You can do this with recursive descent, but it’s a chore.

      Jonathan Blow recently revisited this topic with Casey Muratori. (They last talked about this 3 years ago.)

      What's a little absurd is that (a) the original discussion is something like 3–6 hours long and doesn't use recursive descent—instead they descended into some madness about trying to work out from first principles how to special-case operator precedence—and (b) they start out in this video poo-pooing people who speak about "recursive descent", saying that it's just a really obnoxious way to say writing ordinary code—again, all this after they three years ago went out of their way to not "just" write "normal" code—and (c) they do this while launching into yet another 3+ hour discussion about how to do it right—in a better, less confusing way this time, with Jon explaining that he spent "6 or 7 hours" working through this "like 5 days ago". Another really perverse thing is that when he talks about Bob's other post (Parsing Expressions) that ended up in the Crafting Interpreters book, he calls it stupid because it's doing "a lot" for something so simple. Again: this is to justify spending 12 hours to work out the vagaries of precedence levels and reviewing a bunch of papers instead of just spending, I dunno, 5 or 10 minutes or so doing it with recursive descent (the cost of which mostly comes down to just typing it in).

      So which one is the real chore? Doing it the straightforward, fast way, or going off and attending to one's unrestrained impulse that you for some reason need to special-case arithmetic expressions (and a handful of other types of operations) like someone is going to throw you off a building if you don't treat them differently from all your other ("normal") code?

      Major blind spots all over.

    1. Experts without accountability start acting in their own interests rather than that of their customers/users. And we don’t know how to hold programmers accountable without understanding the code they write.
  9. Dec 2023
    1. Their ideas of possible action vary fromimportant-looking signed pronounce-ments and protests to the withholding ofservices and the refusal to assist in techni-cal developments that may be misap-plied.

      Not too dissimilar from programmers who add licensing to their work now to prevent it from being misused.

    Tags

    Annotators

    1. Solution: Instead of taking notes to use as direct references, make notes that can serve as prompts for further research. It is important to get comfortable with reading documentation, which essentially acts as pre-existing notes made by someone else.

      It is also a good idea to create a developer journal with your different questions, insights, and reasonings that you bump into during your journey. It will also serve you in your career.

    1. Let us change our traditional attitude to the construction of programs: Instead of imagining that our main task is to instruct a computer what to do, let us concentrate rather on explaining to human beings what we want a computer to do.

      In reality, It is a mix between these two attitudes. Programming is being good at telling the computer what to do, in the most efficient way. This whole process requires a good amount of knowledge, design, and thinking. But coding, just the part where you're writing code, should be focused on readability because humans are the ones that interact with the text, not computers.

  10. Nov 2023
    1. One of the ways that, that chat G BT is very powerful is that uh if you're sufficiently educated about computers and you want to make a computer program and you can instruct uh chat G BT in what you want with enough specificity, it can write the code for you. It doesn't mean that every coder is going to be replaced by Chad GP T, but it means that a competent coder uh with an imagination can accomplish a lot more than she used to be able to, uh maybe she could do the work of five coders. Um So there's a dynamic where people who can master the technology can get a lot more done.

      ChatGPT augments, not replaces

      You have to know what you want to do before you can provide the prompt for the code generation.

  11. Oct 2023
    1. What about a literate programming compiler that takes as input this page (as either Markdown or HTML) and then compiles it into the final program?

    1. as much as I love TypeScript, it’s not a native substrate of the web
    2. although they happened to be built with HTML, CSS and JS, these examples were content, not code. In other words, they’d be handled more or less the same as any image or video I would include in my blog posts. They should be portable to any place in which I can render HTML.
    1. (Weight W1) (Rope Rp) (Rope Rq) (Pulley Pa) (hangs W1 from Rp) (pulley-system Rp Pa Rq) (Weight W2) (hangs W2 from Rq) (Rope Rx) (Pulley Pb) (Rope Ry) (Pulley Pc) (Rope Rz) (Rope Rt) (Rope Rs) (Ceiling c) (hangs Pa from Rx) (pulley-system Rx Pb Ry) (pulley-system Ry Pc Rz) (hangs Pb from Rt) (hangs Rt from c) (hangs Rx from c) (hangs Rs from Pc) (hangs W2 from Rs) (value W1 1) (b) P1. P2. P3. P4. .. Single-string support. (weight < Wx>) (rope <Ry >) (value <Wx> <n>) (hangs <Wx> <Ry>) -(hangs <Wx> <Rx>) - (value <Ry> <W-number>) Ropes over pulley. (pulley <P>) (rope <R1>) (rope <R2>) (pulley-system <R1 > <P> <R2>) (value <R1> <nl>) - (value <R2> <nl>) Rope hangs from or supports pulley. (pulley <R1>) (rope <R1>) (rope R2>) (pulley-system <R1> <P> <R2>) { (hangs <R3> from <P>) or (hangs <P> from <R3>) } (value <R1> <nl>) (value <R2> <n2>) - (value <R3> <nl + <n2>) Weight and multiple supporting ropes. (weight <W1 >) (rope <R1 >) (rope R2>) (hangs <W1> <Rl>) (hangs <W1> <R2>) -(hangs <W1> <R3>) (value <R1> <nl>) (value <R2> <n2>) - (value <W1> <nl> + <n2>) P2. Ropes over pulley. If a pulley system < P> has two ropes < RI > and < R2> over it, and the value (tension) associated with < RZ > is < nl > , then < nl > is also the value associated with rope < RZ > . P3. Rope hangs from or supports pulley. If there is a pulley system with ropes < RZ > and < R2> over it, and the pulley system hangs from a rope < R3 > , and c R1> and < R2 > have the values (tensions) < nl > and < n2 > associated with them, then the value (tension) associated with < R3 > is the sum of < nl > plus <n2>.

      Please explain to me how it is not evident to programmers that this is how we program.. we cannot hold more than seven items at a time. We cannot fracture. As Miller mentioned, 2 3 digit numbers are outside t capacity, but if you multiply them by paper w, if we free your memory, we can let the brain focus on the v

      If you assign the memory function to a diagram, you can let your brain concentrate on the manipulation function.

      Once we codify, we no longer have to keep the information in memory, for example : This hurts my brain

      There are five roads in Brown County. One runs from Abbeville to Brownsville by way of Clinton. One runs from Clinton to Derbyshire by way of Fremont. One runs from Fremont to Brownsville by way of Abbieville. That's all the roads in Brown County, and all the roads in and out of those towns.

      Which towns have roads connecting them directly to three other towns? Which towns have roads connecting them directly to only two other towns? How many towns must you pass through to get from Brownsville to Derbyshire?

      But if we diagram it to a map, all of this makes sense.

      "The learning of numbers and language must be subordinated ... Visual understanding is the essential and only valid means of teaching how to judge things correctly." ~ Johann Heinrich Pestalozzi

      Pestalozzi was the guy who designed the educational system in which Einstein, the most extraordinary visualization of his time, was born q

    1. bserved, for example, in the evolution of programming languages

      A 2015 paper See zotero://select/library/items/AMCSEP75

    1. When a language presumes to know more than its user, that's when there's trouble.
    2. Just because a language has a feature that might be dangerous doesn't mean it's inherently a bad thing. When a language presumes to know more than its user, that's when there's trouble.
    3. I'd argue that when you find a programming language devoid of danger, you've found one that's not very useful.
    4. The reason eval is there is because when you need it, when you really need it, there are no substitutes. There's only so much you can do with creative method dispatching, after all, and at some point you need to execute arbitrary code.
  12. Sep 2023
    1. I think "purely functional, not a single re-assigned variable" often introduces significant extra complexity, when Ruby is a language that embraces both functional and imperative programming.
    2. One of my favorite aspects of Ruby is how easy it is to write in a functional programming style, and including the scan operation would expand the number of use cases covered by functional methods.
    1. An object in object-oriented language is essentially a record that contains procedures specialized to handle that record; and object types are an elaboration of record types. Indeed, in most object-oriented languages, records are just special cases of objects, and are known as plain old data structures (PODSs), to contrast with objects that use OO features.
  13. Aug 2023
    1. ```js function createPromiseWithData() { let resolveFn;

      const promise = new Promise((resolve, reject) => { resolveFn = resolve; });

      return { promise, resolveFn }; }

      // Usage const { promise, resolveFn } = createPromiseWithData();

      // Later, when you have the data you want to pass const data = 'Future data';

      // Resolve the promise with the data resolveFn(data);

      // Use the promise promise.then((result) => { console.log('Promise resolved with:', result); }); ```

  14. Jul 2023
    1. Colaroid’s unique ap-proach to literate programming is to bring together the rich textediting affordances of notebooks together with automated creationof contextualized code snippets showing code differences, and closeintegration of the literate document into an IDE where code can betinkered with.

      This misses the point of LP—the true "fundamental theorem of LP" is basically that the compiler should be made to accept the preferred form.

    Tags

    Annotators

    1. REPLs are nice but they work well only for reasonably isolated code with few dependencies. It's hard to set up a complex object to pass into a function. It's harder still to set up an elaborate context of dependencies around that function.

      I wonder how much of this is accomplishable by automatically parameterizing code by the types that aren't used internally so they implementation can forget about the specifics. In addition some sort of meta-programming capability to automatically generate arbitrary instances or a richer form of trace types for user types would go a long way to simplifying the trace generation.

  15. Jun 2023
    1. under the name “conversion functions.” These exist in Ruby’s standard library - for example Array() is one that you’re likely to see in real code.
    1. Five core layers: 1. Presentation Layer 2. Application Layer 3. Domain Layer 4. Persistence Layer 5. Database Layer

    2. In the layered architecture pattern, each layer fulfills a specific responsibility and role within the application. Some focus on user interface logic, while others handle the execution of business rules. These layers complement each other's unique purposes, but they aren't explicitly reliant on one another to perform their own tasks.
    3. In software architecture, layers act as individual processes within the infrastructure of an application. These layers typically form a pattern, also called the n-tier architecture pattern.
    1. Public and/or protected fields are bad because they can be manipulated from outside the declaring class without validation; thus they can be said to break the encapsulation principle of object oriented programming.
    2. When you lose encapsulation, you lose the contract of the declaring class; you cannot guarantee that the class behaves as intended or expected.
    3. Using a property or a method to access the field enables you to maintain encapsulation, and fulfill the contract of the declaring class.
    4. Exposing properties gives you a way to hide the implementation. It also allows you to change the implementation without changing the code that uses it (e.g. if you decide to change the way data are stored in the class)
    5. Anything that isn't explicitly enforced by contract is vulnerable to misunderstandings. It's doing your teammates a great service, and reducing everyone's effort, by eliminating ambiguity and enforcing information flow by design.
    1. Derived classes need to follow their base class contracts, but may choose to expose a subtype of base class with more capabilities. This includes making protected members public:
    2. TypeScript offers special syntax for turning a constructor parameter into a class property with the same name and value. These are called parameter properties

      Doesn't this violate their own non-goal #6, "Provide additional runtime functionality", since it emits a this.x = x run-time side effect in the body that isn't explicitly written out in the source code?

    3. Member Visibility
    1. Practically speaking, if you can't think of a reason why it would be dangerous then theres more to be gained by opting for extensibility.
    2. If it's dangerous, note it in the class/method Javadocs, don't just blindly slam the door shut.
    3. When a developer chooses to extend a class and override a method, they are consciously saying "I know what I'm doing." and for the sake of productivity that should be enough. period.
    1. Reflection adds the ability to reverse-engineer classes, interfaces, functions, methods and extensions. Additionally, they offers ways to retrieve doc comments for functions, classes and methods.
    1. kons-9 is that it combines the power of a software development IDE with the visual tools of 3D graphics authoring system. It does this by being implemented in Common Lisp, an object-oriented dynamic language which provides powerful facilities for exploratory development and rapid prototyping within a live interactive software environment

      IDE + 3D + Lisp = Unique features:: * software development IDE with visual toold of 3d graphics authoring system * unlimited extensibility (no distinction between developers and end users)

      https://youtu.be/NJe4isZ7NHI

    2. REPL-based

      Read-Eval-Print Loop and is a software programming environment that allows developers to interactively execute their code

    1. Developers often speak of "getting into the flow" or "being in the zone." Such statements colloquially describe the concept of flow state, a mental state in which a person performing an activity is fully immersed in a feeling of energized focus, full involvement, and enjoyment.

      One of my favourite explanations of the flow state

  16. May 2023
    1. From Jim Keller on Lex, there’s three fundamental types of compute CPU: add, multiply, load, store, compare, branch (nothing can be known about anything) GPU: add, multiply, load, store (when things happen is known, but the addresses aren’t) DSP: add, multiply (everything is known except the data) Neural networks are DSPs. All the loads and stores can be statically computed, which isn’t even possible for GPU workloads, never mind CPU ones.
    1. Emphasizing lifetime-polymorphism can also make type inference untenable, a design choice that wouldn’t fit OCaml.

      References or sources? Why? Presumably there's some research into this?

    1. I think that TANGLE-style reordering is a lot less important with modern programming languages: they don't do one-pass compilation and so can deal with forward references. Note that most of the cross-references in Knuth's program could be replaced with function calls or constant names
    1. I felt he had just written the program where the default was comment without delimiters (i.e. most just changed the syntax for the compiler).
    1. Web sites often design their APIs to optimize performance forcommon cases. Their main object-reading methods may return onlycertain “basic” properties of objects, with other methods availablefor fetching other properties. ShapirJS hides this performanceoptimization complexity from the user.

      In other words, it risks undermining the intent of the API design.

  17. stackoverflow.com stackoverflow.com