Description
Hive Rewards SDK is an open-source npm library. To track HIVE-based earnings. And interact with Hive ecosystem APIs. Making it accessible for both developers and end users. It features automatic price lookups and node management. With tools for querying earnings over various timeframes. Enhancing user experience and reliability in managing Hive transactions.
Description
DeepWiki is an AI tool that creates a searchable wiki for GitHub repositories. Allowing developers to ask specific questions about their codebases. Then receive accurate answers with code examples. See this practical application of AI in enhancing code understanding. Rather than replacing developers.
Display problems at the Hive frontend
Do you have display issues on the Hive blogging platform? Specifically regarding the alignment of text and images in blog posts. See these formatting problems. And see if you can help.
How I Created VNC App using Bolt and Cursor
Creating a VNC service app using Bolt and Cursor. See the challenges of development. And the struggle to establish a monetization plan. Learn the value of open-source solutions in a market dominated by large corporations. With hope for future sustainability.
From NavBar Mess to React Router Success! Fixing Layouts, Routing & AIOHA in One Go 🚀
Transforming a chaotic navigation bar into a functional component using React Router. While also integrating AIOHA for user authentication. And creating a reusable layout to streamline React app development. The update emphasizes improvements in user experience and code organization. As foundational steps for their ongoing project.
Level Up Your Imports: Using Path Aliases for Cleaner React + TypeScript Projects 🚀
A guide on using path aliases in React and TypeScript projects. To simplify and clean up import statements. Making code easier to maintain. See a step-by-step process for setting up path aliases. Ultimately transitioning from cumbersome relative imports to more readable ones.
🧭 Integrating React Router: My Routing Adventures with React 🛣️
How to integrate React Router into a new React application. See the steps to set up routing and create basic pages. While humorously acknowledging challenges faced along the way. Particularly with adding a navigation bar. Join the journey of learning and experimenting with React development today.
Day 4 ReactJS Adventures + Distriator Progress: useState, useEffect, and .env Chaos 😹
For ReactJS projects, you need to learn the useState and useEffect hooks. See the challenges faced while integrating environment variables in a Vite-based React app. With practical progress on the Distriator project. Including the successful integration of hotel room data and a live deployment.
Day 8 - Secure 🔐 Login with AIOHA & LocalStorage Magic 🧙
Day 8 of the ReactJS learning journey is about implementing a secure login system using AIOHA and localStorage. Learn the use of AES encryption for storing user data safely. With managing multiple Hive logins. Also, a detailed explanation of the login API integration and data handling processes.
🚀 **Day 9 – Toasts, Laughs & Custom Magic!** 🍞✨
This ReactJS learning journey shows how to create and customize a custom toast component. Complete with various styles and icons. To enhance user notifications. See insights from previous learning days. With humor and enthusiasm for the coding process.
Day 6 🚀 - Learning ReactJS: Calling APIs & Creating Context Providers | Distriator Feature Update
Learning ReactJS to call APIs and implement Context Providers for managing business data. See a new feature in the Distriator project that displays the Hive Power of businesses. Emphasizing the importance of organized code structure and TypeScript for predictable data handling.
🚀 Integrate AIOHA with Your React App from Scratch (Vite + Tailwind + DaisyUI)
A step-by-step guide on integrating the AIOHA login system into a React application using Vite, Tailwind, and DaisyUI. It covers project setup, component creation, and debugging. To help developers enhance their apps with Hive blockchain login functionality.
What I call software collapse is what is more commonly referred to as software rot: the fact that software stops working eventually if is not actively maintained. The rot/maintenance metaphor is not appropriate in my opinion because it blames the phenomenon on the wrong part. Software does not disintegrate with time. It stops working because the foundations on which it was built start to move.
I’d like to share the process of porting the original codebase from ~67,000 lines of C code to ~81,000 lines of Rust
Interesting outcome. Rarely (basically never) do you see "it's more verbose to write in $LANG2 what would be written in fewer lines if you were using $LANG1" touted as a positive.
Allows for code to become “portable” between files since the code can carry most of its external dependencies inside of itself, making refactoring a bit easier.
including 10s to download the crates every time
What are overlay SCMs supposed to actually achieve again?
Upgrading tools would frequently break compatibility with existing data. And it was difficult to make different tools interoperate if they couldn’t agree exactly on the format of their underlying JSON data.
Why should the app even know let alone care about which version of the serialization format is in play?
LLMs can write a large fraction of all the tedious code you’ll ever need to write. And most code on most projects is tedious. LLMs drastically reduce the number of things you’ll ever need to Google. They look things up themselves. Most importantly, they don’t get tired
Does this mean arguments against verbose "boilerplate" languages are going to be given less credence?
For example, the syntactic analysis stage builds a conventional expression tree, but this tree is expressed as objects—instances of various classes relevant to compilation: Class, Method, Message, Selector, Argument, etc. […] The code for these operations is encapsulated inside each object, and is not spread throughout the system so changes are easily made. And all these specialized classes rely heavily on reusable code inherited from more primitive classes like Object, HashTable, Symbol, Token, and LinkedList.
This is an interesting claim, given that one of the common criticisms of the classic, inheritance-heavy style of classic OOP is precisely that it leads to code that is indeed "spread throughout". Adele Goldberg commenting on the legacy of Smalltalk made a well-known quip, "In Smalltalk, everything happens somewhere else."
It's notable that although there many common word sequences between this paper and the later, similarly titled one that appeared in IEEE Software (1984), this passage doesn't appear to be present (based on a quick skim—I could be missing something), and the closest corresponding statements are significantly reworded.
Although many of the hypotheses in this field are unproved
Are they even well-formed hypotheses? That is, are they falsifiable?
Software does not need dusting, waxing, or cleaning. It often does have faults that do need attention, but this is not maintenance, but repair. Repair is fixing something that has been broken by tinkering with it, or something that has been broken all along. Conversely, as the environment around software changes, energy must be expended to keep it current. This is not maintenance; holding steady to prevent decline.
FPThe functional programming submodule provides a better alternative to chaining: composition; which makes your code clean and safe and doesn't bloat your build.
Detailed Summary
1. You own your data, in spite of the cloud. <br /> Section summary: <br /> Local-fist software tries to solve the problem of ownership, agency and data lock-in present in cloud-based software, without compromising cross-collaboration and improving user control.
Section breakdown<br /> §1: SaaS<br /> Pros: Easy sync across devices, real-time collab Cons: loss of ownership and agency; loss of data is software is lost.
§2: Local-fist software<br /> - Enables collaboration & ownership - Offline cross-collaboration - Improved security, privacy, long-term preservation & user control of data
§3 & §4: Article Methodology<br /> - Survey of existing storage & sharing approaches and their trade-offs - Conflict-free Replicated Data Types (CRDTs), natively multi-user - Analysis of challenges of the data model as implemented at Ink & Switch - Analysis of CRDT viability, UI - Suggestion of next steps
2. Motivation: collaboration and ownership<br /> Section summary: <br /> The argument for cross-device, real-time collab PLUS personal ownership
Section breakdown<br /> §1: Examples of online collabs<br /> §2: SaaS increasingly critical, data increasingly valuable<br /> §3: There are cons<br /> §4: Deep emotional attachment to your data brings feeling of ownership, especially for creative expression<br /> §5: SaaS require access to 3rd party server, limitation on what can be done. Cloud provider owns the data.<br /> §6: SaaS: no service, no data. If service is shut down, you might manage to export data, but you may not be able to run your copy of the software.<br /> §7: Old-fashioned apps were local-disk based (IDEs, git, CAD). You can archive, backup, access or do whatever with the data without 3rd party approval.<br /> §8: Can we have collaboration AND ownership?<br /> §9: Desire: cross-device, real-time collab PLUS personal ownership
3. Seven ideals for local-first software<br /> Section breakdown<br /> §1: Belief: data ownership & real-time collab are compatible<br /> §2: Local-first software local storage & local networks are primary, server secondary<br /> §3: SaaS: In the server, or it didn't happen. Local-first: local is authoritative, servers are for cross-device.
3.1.1 No spinners<br /> SaaS feels slower because if requires round-trip to a server for data modification and some lookups. Lo-Fi doesn't have dependency on server, data sync happens on the background. This is no guarantee of fast software, but there's a potential for near-instant response.<br /> 3.1.2 Data not trapped on one device <br /> Data sync will be discussed in another section. Server works as off-site backup. The issue of conflict will also be discussed later.<br /> 3.1.3 The network is optional<br /> It's difficult to retrofit offline support to SaaS. Lo-Fi allows CRUD offline and data sync might not require the Internet: Bluetooth/local Wi-fi could be enough.<br /> 3.1.4 Seamless collabs<br /> Conflicts can be tricky for complex file formats. Google Docs became de facto standard. This is the biggest challenge for Lo-Fi, but is believed to be possible. It's also expected that Lo-Fi supports multiple collab.
TBC
I've been considering what it would look like to have state machines / state charts as a direct language primitive. I'm sure there are some out there. Is it actually a good idea? Are variant/enum types with pattern matching enough?
Before adding a new SSH key to the ssh-agent to manage your keys, you should have checked for existing SSH keys and generated a new SSH key. When adding your SSH key to the agent, use the default macOS ssh-add command, and not an application installed by macports, homebrew, or some other external source. Start the ssh-agent in the background. $ eval "$(ssh-agent -s)" > Agent pid 59566 Depending on your environment, you may need to use a different command. For example, you may need to use root access by running sudo -s -H before starting the ssh-agent, or you may need to use exec ssh-agent bash or exec ssh-agent zsh to run the ssh-agent. If you're using macOS Sierra 10.12.2 or later, you will need to modify your ~/.ssh/config file to automatically load keys into the ssh-agent and store passphrases in your keychain. First, check to see if your ~/.ssh/config file exists in the default location. $ open ~/.ssh/config > The file /Users/YOU/.ssh/config does not exist. If the file doesn't exist, create the file. touch ~/.ssh/config Open your ~/.ssh/config file, then modify the file to contain the following lines. If your SSH key file has a different name or path than the example code, modify the filename or path to match your current setup. TextHost github.com AddKeysToAgent yes UseKeychain yes IdentityFile ~/.ssh/id_ed25519 Host github.com AddKeysToAgent yes UseKeychain yes IdentityFile ~/.ssh/id_ed25519 Note If you chose not to add a passphrase to your key, you should omit the UseKeychain line. If you see a Bad configuration option: usekeychain error, add an additional line to the configuration's' Host *.github.com section. TextHost github.com IgnoreUnknown UseKeychain Host github.com IgnoreUnknown UseKeychain Add your SSH private key to the ssh-agent and store your passphrase in the keychain. If you created your key with a different name, or if you are adding an existing key that has a different name, replace id_ed25519 in the command with the name of your private key file. ssh-add --apple-use-keychain ~/.ssh/id_ed25519 Note The --apple-use-keychain option stores the passphrase in your keychain for you when you add an SSH key to the ssh-agent. If you chose not to add a passphrase to your key, run the command without the --apple-use-keychain option. The --apple-use-keychain option is in Apple's standard version of ssh-add. In macOS versions prior to Monterey (12.0), the --apple-use-keychain and --apple-load-keychain flags used the syntax -K and -A, respectively. If you don't have Apple's standard version of ssh-add installed, you may receive an error. For more information, see Error: ssh-add: illegal option -- apple-use-keychain. If you continue to be prompted for your passphrase, you may need to add the command to your ~/.zshrc file (or your ~/.bashrc file for bash). Add the SSH public key to your account on GitHub. For more information, see Adding a new SSH key to your GitHub account. If you have GitHub Desktop installed, you can use it to clone repositories and not deal with SSH keys. In a new admin elevated PowerShell window, ensure the ssh-agent is running. You can use the "Auto-launching the ssh-agent" instructions in Working with SSH key passphrases, or start it manually: # start the ssh-agent in the background Get-Service -Name ssh-agent | Set-Service -StartupType Manual Start-Service ssh-agent In a terminal window without elevated permissions, add your SSH private key to the ssh-agent. If you created your key with a different name, or if you are adding an existing key that has a different name, replace id_ed25519 in the command with the name of your private key file. ssh-add c:/Users/YOU/.ssh/id_ed25519 Add the SSH public key to your account on GitHub. For more information, see Adding a new SSH key to your GitHub account. Start the ssh-agent in the background.
The benefit to ssh-agent is that you only need to enter your passphrase once. If your private RSA key is not encrypted with a passphrase, then ssh-agent is not necessary
Cursor noted Claude is once again best-in-class for real-world coding tasks, with significant improvements in areas ranging from handling complex codebases to advanced tool use. Cognition found it far better than any other model at planning code changes and handling full-stack updates. Vercel highlighted Claude’s exceptional precision for complex agent workflows, while Replit has successfully deployed Claude to build sophisticated web apps and dashboards from scratch, where other models stall. In Canva’s evaluations, Claude consistently produced production-ready code with superior design taste and drastically reduced errors.
Claude 3.7 Sonnet again excels at coding, as verified by multiple teams
In extended thinking mode, it self-reflects before answering, which improves its performance on math, physics, instruction-following, coding, and many other tasks.
About Claude 3.7 Sonnet
function loggable(target: any, propertyKey: string, descriptor: PropertyDescriptor) { let originalMethod = descriptor.value; descriptor.value = function(...args: any[]) { console.log(`Calling ${propertyKey}`); return originalMethod.apply(this, args); }; }
There is a tremendous power in thinking about everything as a single kind of thing, because then you don’t have to juggle lots of different ideas about different kinds of things; you can just think about your problem.
In my experience this is also the main benefit of using node.js as your backend. Being able to write your front and backend code in the same language (javascript) removes a switching cost I didn't fully realize existed until I tried node the first time.
On most real life projects, the speed of development is easily worth an occasional corner case bug with an unexpected nil value … except when it isn’t.
speed of development vs. safety
Wrapping my head around what git-backed database would mean, finding it quite cool
Furthermore, our research demonstrates that the acceptance rate rises over time and is particularly high among less experienced developers, providing them with substantial benefits.
less experienced developers accept more suggeted code (copilot) and benefit relatively versus more experienced developers. Suggesting that the set ways of experienced developers work against fully exploting code generation by genAI.
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.
Rails' observers were partly inspired by aspect-oriented programming -- they're about cross-cutting concerns. If you're putting business logic in observers that is tightly coupled to the models they're observing, you're doing it wrong IMO.
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.
Sure, it is not needed, we can always write things in a different way. As a matter of fact, with such an argument, hardly any improvement should be accepted.
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.
Examples by languages
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.
But you're able to remove (usually inherited) fields by: class ChildForm < ParentForm remove_field :field_from_parent end
memoize :call, condition: -> { environment == 'production' }
A programming model is an execution model coupled to an API or a particular pattern of code.
JavaScript Flashcards
App with javascript interview questions
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
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.
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.
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.
See also Raskin on: * The Woes of IDEs * Comments are more important than code
Tutorial Hell
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.
Tutorial Hell
How: The author discusses two concepts of Tutorial Hell
How it impacts learning
Then, he provides tips on how to escape Tutorial Hell by:
The author also shares personal experiences and examples to illustrate his points.
Tutorial Hell
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>
Tutorial Hell
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.
The ratio of time spent on precedence parsing in compilers to utility feels very low
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/
Testrpc
shrink-wrap on blender
Here are some examples of pages about the Shrinkwrap modifier for Blender:
Installing testRPC/ganache-cli
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) You will rarely get greenfield projects
:)
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.
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
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
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
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.
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
Try the TOSEC archive for C64. You will also find that in the archive. I think they have a lot of those type-ins as .prg files so you can mount them in VICE and run them.
https://www.reddit.com/r/c64/comments/1bg0ja1/does_anyone_have_the_zettelkasten_program_from/
social dynamics in tech jobs punish people who say things like, “Uh, this is too complicated to me.”
Do not pass arguments right into subshell, it's as unsafe as eval.
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.
Python 3
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.
My First dApp
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.
Ethereum TestRPC vs Geth
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?
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.
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.
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.
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.
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.
One language that is currently being developed, Rascal, takes a hybrid approach allowing dynamic typing within functions but enforcing static typing for the function signature.
first sighting: Rascal
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.
You have to know what you want to do before you can provide the prompt for the code generation.
The key and only feature that makes JavaScript object-oriented is the humble and error-prone this
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?
the thought of a richly self-documenting script
as much as I love TypeScript, it’s not a native substrate of the web
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.
(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
bserved, for example, in the evolution of programming languages
A 2015 paper See zotero://select/library/items/AMCSEP75
When a language presumes to know more than its user, that's when there's trouble.
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.
I'd argue that when you find a programming language devoid of danger, you've found one that's not very useful.
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.
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.
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.
You just blew my mind Marc-André. My code just went from idiotic to idiomatic.
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.
```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); }); ```
category theory + zettelkasten... hmmm... feels a bit like Leibniz chasing a universal language
what is a zettelkasten monad?
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.
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.
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.
Five core layers: 1. Presentation Layer 2. Application Layer 3. Domain Layer 4. Persistence Layer 5. Database Layer
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.
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.
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.
When you lose encapsulation, you lose the contract of the declaring class; you cannot guarantee that the class behaves as intended or expected.
Using a property or a method to access the field enables you to maintain encapsulation, and fulfill the contract of the declaring class.
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)
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.
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:
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?
Member Visibility
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.
If it's dangerous, note it in the class/method Javadocs, don't just blindly slam the door shut.
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.
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.
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)
REPL-based
Read-Eval-Print Loop and is a software programming environment that allows developers to interactively execute their code
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
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.
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?
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
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).
General solutions are more complex than specific ones.
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.
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!
'handlers': { 'console': { 'level': 'INFO', 'class': 'logging.StreamHandler', 'stream': sys.stdout, 'formatter': 'verbose' }, },
It's as simple as adding "sys.stdout" to the "stream" attribute.
16 August 2011
This is a pretty old article, from 2011. Note that it refers to Python 2.6 and 2.7. Today, Python is up to version 3.12.
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.
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.
"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
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.
A hypertext link is a goto.
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
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.
https://www.s4c.cymru/en/international/
https://www.s4c.cymru/clic/
Hello from S4C - Welsh - SSi Forum<br /> by sara-peacock-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
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
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
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.
The difference between object-oriented design and object-orientedprogramming
What is the design and programming mean in OOP?
