1,227 Matching Annotations
  1. Last 7 days
    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>
  2. Apr 2024
    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.

  3. 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

  4. 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.
  5. 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.
  6. 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.

  7. 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.

  8. 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.
  9. 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.
  10. 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); }); ```

  11. 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.

  12. 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

  13. 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.

    1. How can I add, subtract, and compare binary numbers in Python without converting to decimal?

      I think the requirements of this were not spelled out well. After reading this over a couple of times, I think the problem should be…

      "Add, subtract, and compare binary numbers in Python as strings, without converting them to decimal."

      I'll take on that problem sometime when I get free time!

    1. 'handlers': { 'console': { 'level': 'INFO', 'class': 'logging.StreamHandler', 'stream': sys.stdout, 'formatter': 'verbose' }, },

      It's as simple as adding "sys.stdout" to the "stream" attribute.

    1. Available as a monolithic file, by chapters, and in PDF — git repository.

      What a cool documentation design; I love the all-in-one layout.

      Very reminiscent of the old CoffeeScript docs, to me.

  14. Apr 2023
    1. Here we have extended this model to a slightly different category, a category where morphisms are represented by embellished functions, and their composition does more than just pass the output of one function to the input of another. We have one more degree of freedom to play with: the composition itself. It turns out that this is exactly the degree of freedom which makes it possible to give simple denotational semantics to programs that in imperative languages are traditionally implemented using side effects.
  15. Mar 2023
    1. "We could use this type of DB, or this other, or that other, and these are some pros and cons… And based on all these tradeoffs, I’ll use THAT type of DB."

      Example of how to recommend a single system

    2. The difference between coding and system design is the difference between retrieving and creating.Instead of finding (or “retrieving”) a solution, you are creating a solution. In this way, coding is akin to a science, while system design is more like an art.
    1. So why aren't more people using Nim? I don't know! It's the closest thing to a perfect language that I've used by far.

      Nim sounds as the most ideal language when comparing to Python, Rust, Julia, C#, Swift, C

    1. It isn't a good long term solution unless you really don't care at all about disk space or bandwidth (which you may or may not).

      Give this one another go and think it through more carefully.

  16. Feb 2023
    1. Object-oriented Programming (OOP) is the process of converting this perfectlydefined design into a working program that does exactly what the CEOoriginally requested.

      OOP

    2. Object-oriented Design (OOD) is the process of converting such requirements intoan implementation specification. The designer must name the objects, define thebehaviors, and formally specify what objects can activate specific behaviors onother objects. The design stage is all about how things should be done. The outputof the design stage is an implementation specification. If we were to complete thedesign stage in one step, we would have turned the requirements into a set ofclasses and interfaces that could be implemented in (ideally) any object-orientedprogramming language.

      OOD

    3. Object-oriented Analysis (OOA) is the process of looking at a problem, system,or task that somebody wants to turn into an application and identifying the objectsand interactions between those objects. The analysis stage is all about what needsto be done. The output of the analysis stage is a set of requirements. If we were tocomplete the analysis stage in one step, we would have turned a task, such as, "Ineed a website", into a set of requirements, such as:Visitors to the website need to be able to (italic represents actions, boldrepresents objects):review our historyapply for jobsbrowse, compare, and order our products

      OOA

    4. What object-oriented means

      What does the object-oriented means? Objects are models of somethings that can do certain things and have certain things done to them. Formally, an object is a collection of data and associated behaviors.

    5. The difference between object-oriented design and object-orientedprogramming

      What is the design and programming mean in OOP?

    Tags

    Annotators