https://www.reddit.com/r/Zettelkasten/comments/yd7t7u/creating_a_zk_dont_break_the_chain_calendar_in/\

Much like the way the Obsidian journal plugin counts words within one's daily journal page, this app counts zettels within a folder to help encourage one to maintain some level of output.

Lots of comments here reminiscent about this restatement of the true purpose of the free software movement:

I know it's socially acceptable[...] to dump on Stallman's "software freedom"—or at least the choice of words to describe it—but this is exactly the kind of thing that it is meant to address. Superficially, Signal might look like it has the right accoutrements, having adopted a FOSS license and all, but it's not free software. Nothing that holds folks' systems and data hostage unless you comply with the program author's whims can be considered FOSS.

See also: Why Open Source Misses the Point of Free Software

@1:10:20

With HTML you have, broadly speaking, an experience and you have content and CSS and a browser and a server and it all comes together at a particular moment in time, and the end user sitting at a desktop or holding their phone they get to see something. That includes dynamic content, or an ad was served, or whatever it is—it's an experience. PDF on the otherhand is a record. It persists, and I can share it with you. I can deliver it to you [...]

NB: I agree with the distinction being made here, but I disagree that the former description is inherent to HTML. It's not inherent to anything, really, so much as it is emergent—the result of people acting as if they're dealing in live systems when they shouldn't.

Breitenbach, H. P. “The Card Index for Teachers.” The School Review 20, no. 4 (1912): 271–72.

Apparently in 1912, the card index was little known to teachers... this isn't the sort of use case I was expecting here...

The general gist of this short note is an encouraging one to suggest that instead of traditional grade books, which are still used heavily in 2022, teachers should use rolodex like cards for keeping attendance and notes on a student's progress.

Presumably this never caught on. While some elementary teachers still use older paper gradebooks, many others have transferred to digital LMS platforms.

Fuck. I forgot the iPad and I have the same goddamned birthday.

Amazon does a platform as a hostage taker move on Twitch streamers.

Surgical Scheduling Software Powerful technology thats simple to use

PreferredMD Solutions - connecting patients, physicians, and facilities in one HIPAA-compliant platform. Simplify surgery center management workflows for more efficient, transparent health care.

CTO services, or CTOaaS, stands for part-time tech and business advisory of the Chief Technology Officer to assist Small and Medium-sized Enterprises (SMEs).

The core benefit of a startup fractional CTO compared to an in-house CTO is the price effectiveness of such a service as a company only pays for the services needed.

I think this is true, but it's often difficult to design generality upfront. A nice approach is making sure that you are able to back into it and modify after the fact.

We should be trying to make our technologies have more "two-door" decisions.

Which software package have you used before? Please list some pros and cons of that software package.

still widely held today

Stumbling across obscure/obscured shit like this in these operating systems used to be legitimately fun but uh... Well, it's been a while.

It works ridiculously well though! As in, the import process can handle far too many notes far too quickly for the device's actual ability to index them lol.

"can't is too strong a word here"

The truth of this has consequences not just for the metaissue of recomputation, but the entire raison d'etre of doing performance studies to begin with.

"The greatest performance improvement of all is when a system goes from not-working to working"

That seems like unnecessarily tight coupling. Surely there's a better level of abstraction that's higher than "emulate the hardware platform".

5 ERP system examples (who benefits from ERP?)

The term EnterpriseResourcePlanning (ERP) system refers to a large number of integrated softwaresuites used by companies to manage day-to-day operations and business workflows, including datamanagement, inventory control, accounting, CRM, and projectmanagement. Thus, in order to remain an effective contender in an era of digital commerce, ERP_systems are an important part of the business information technology infrastructure.

Imenso Software is a client focused custom software development company. Whether you need custom web development or an appealing website design, Imenso has the required expertise and experience to do it all.

While you still can, I'd highly encourage you to use TweetDeck's "Export" List function to save plain text lists of the @ names in your... Lists.

Note that GH doesn't use FK (at least back in 2016) https://github.com/github/gh-ost/issues/331#issuecomment-266027731 due to: * MySQL doesn't support it on partitioned tables * Performance impact. * FKs don't work well with online schema migrations

From Postgres has foreign keys to be fully compatible with partitioned tables since 12. But still it's not that commonly used for larger DBs.

This happens relatively often, especially for 1) engineers that run SQL queries directly against the DB for analysis or triaging production issues, and 2) data scientists that do not use the same programming language as the enginners

Lightroom, Luminar AI, and ON1 Photo RAW were mentioned in the list. These are RAW editors used before Photoshop. The shot is then brought into Photoshop (or another editor) for local modifications. Lightroom and Photoshop are used. Thanks!

https://www.bookstackapp.com/

mentioned by Jim Groom as one of the most popular wiki software available on Github

BookStack is a simple, self-hosted, easy-to-use platform for organising and storing information

I shall always love you, StarPterano. NEVER DIE.

I may be insane, but somehow text search here makes me wonder that Calibre might actually make an interesting interface for keeping one's notes?

Document management, text search, tagging, reference management capabilities, open source, custom meta data, server potential, etc. What's missing to prevent such an off-label use case?

https://liliputing.com/2022/07/calibre-6-0-ebook-manager-gains-full-text-search-arm-cpu-support-and-read-aloud-to-the.html

Syndication link: https://twitter.com/ChrisAldrich/status/1547689914078179328

See also http://cr.yp.to/qhasm/literature.html

@18:52:

I wanna also dig a little more into the kind of... dynamism, ease-of-making-changes thing, because I think there's actually two ways to look at the ease of making changes when you solve a problem with software. One way is to make software sufficiency sophisticated so that you can swap any arbitrary part out and you can keep making changes. The other is to make the software so simple that it's easy to rewrite and you can just rewrite it when the constraints change.

Have you ever heard about embedded software designing?

This involves designing multiple layers according to the device - Application layer, Middle layer, and Software layer

Here's the practical and technical guide to understand the components that make up an embedded systems architecture.

https://wptavern.com/classicpress-on-the-rocks-directors-resign-new-leadership-installed

Point of sale software is someting that’s integral to modern retail. Learn how to build POS software of your own and make your business more efficient and convenient to both your staff and customers.

Previously: Open Source Is Not Enough and Free software is not enough: on practical user freedom.

See also: "Even GNU's philosophy has a few puzzle pieces missing from the box."

It's worth introspecting on why any given person might hesitate to feel that they can commit. This is almost always comes down to "maintainability"—websites are, like many computer-based endeavors, thought of as projects that have to be maintained. This is a failure of the native Web formats to appreciably make inroads as a viable alternative to traditional document formats like PDF and Word's .doc/.docx (or even the ODF black sheep). Many people involved with Web tech have difficulty themselves conceptualizing Web documents in these terms, which is unfortunate.

If you can be confident that you can, today, bang out something in LibreOffice, optionally export to PDF, and then dump the result at a stable URL, then you should feel similarly confident about HTML. Too many people have mental guardrails preventing them from grappling with the relevant tech in this way.

Debugging and debugging software

Debugging is the process of finding and removing errors (bugs) from a software program. Bugs occur in programs when a line of code or a statement conflicts with other elements of the code. We also call errors or defects in hardware bugs.

Black Box testing: Software on the rack

Black Box testing is defined as a testing technique in which the functionality of an application is tested without looking at the internal code structure, implementation details and knowledge of internal paths of the software. This type of testing is completely based on software requirements and specifications.

Considering how I've been publicly speaking and behaving (melodramatically, that is) - as someone who has returned to using my iPhone as my primary working device - this sort of oversight is precisely what I expected, actually, What I did not expect of Apple was to respond as early as the next numeric release to this omission.

Running this very first build of iOS 16, I can indeed that Apple has thought of at least one original context for Quick Note creation, but obviously, it's quite hard to say at this point.

Anywho/how, here's what it looks like at the moment.

This page is excellent for an example of HTML being an adequate substitute for traditional office formats.

See also: The Pinocchio Problem

7 Software Test Principles

It is important that you achieve optimal test results with software testing without deviating from the test goal. But how do you determine whether you are following the right test strategy? For this you have to follow a number of basic principles.

The Eureka Moment in Agile Teams

Any software developer will recognize it, The Eureka Moment. This is when you suddenly see how to solve a particular problem. We have them in all shapes and sizes and at the strangest moments. How does that work in SCRUM and DevOps teams?

xml <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:doap="http://usefulinc.com/ns/doap#"> <doap:Project> <doap:name>Example project</doap:name> <doap:homepage rdf:resource="http://example.com" /> <doap:programming-language>javascript</doap:programming-language> <doap:license rdf:resource="http://example.com/doap/licenses/gpl"/> </doap:Project> </rdf:RDF>

```xml

<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns='http://usefulinc.com/ns/doap#' xmlns:xmpp='https://linkmauve.fr/ns/xmpp-doap#' xmlns:schema='https://schema.org'> <Project> <name>poezio</name>

<created>2010-01-10</created>

<shortdesc xml:lang='en'>Free console XMPP client</shortdesc>
<shortdesc xml:lang='fr'>Client XMPP libre en console</shortdesc>

<description xml:lang='en'>Free and modern console XMPP client written in Python with the ncurses library</description>
<description xml:lang='fr'>Client console XMPP libre et moderne, écrit en Python avec la bibliothèque ncurses</description>

<homepage rdf:resource='https://poez.io/'/>
<schema:documentation rdf:resource='https://doc.poez.io/'/>
<download-page rdf:resource='https://poez.io/#download'/>
<bug-database rdf:resource='https://lab.louiz.org/poezio/poezio/-/issues'/>
<developer-forum rdf:resource='xmpp:poezio@muc.poez.io?join'/>
<support-forum rdf:resource='xmpp:poezio@muc.poez.io?join'/>

<license rdf:resource='https://git.poez.io/poezio/plain/COPYING'/>

<language>en</language>

<schema:logo rdf:resource='https://poez.io/img/logo.svg'/>
<schema:screenshot rdf:resource='https://poez.io/img/screenshot.png'/>

<programming-language>Python</programming-language>

<os>Linux</os>

<category rdf:resource='https://linkmauve.fr/ns/xmpp-doap#category-client'/>

<repository>
  <GitRepository>
    <browse rdf:resource='https://lab.louiz.org/poezio/poezio'/>
    <location rdf:resource='https://lab.louiz.org/poezio/poezio.git'/>
  </GitRepository>
</repository>

<implements rdf:resource='https://xmpp.org/rfcs/rfc6120.html'/>
<implements rdf:resource='https://xmpp.org/rfcs/rfc6121.html'/>
<implements rdf:resource='https://xmpp.org/rfcs/rfc6122.html'/>
<implements rdf:resource='https://xmpp.org/rfcs/rfc7590.html'/>

<implements>
  <xmpp:SupportedXep>
    <xmpp:xep rdf:resource='https://xmpp.org/extensions/xep-0030.html'/>
    <xmpp:status>complete</xmpp:status>
    <xmpp:version>2.5rc3</xmpp:version>
    <xmpp:since>0.5</xmpp:since>
    <xmpp:note xml:lang='en'>The 'disco' plugin can be loaded to make manual queries.</xmpp:note>
    <xmpp:note xml:lang='fr'>Le plugin 'disco' peut être chargé pour faire des requêtes manuellement.</xmpp:note>
  </xmpp:SupportedXep>
</implements>
<!-- And a lot more! -->

<release>
  <Version>
    <revision>0.13.1</revision>
    <created>2020-05-31</created>
    <file-release rdf:resource='https://lab.louiz.org/poezio/poezio/-/archive/v0.13.1/poezio-v0.13.1.tar.gz'/>
  </Version>
</release>

</Project> </rdf:RDF> ```

https://www.theverge.com/2022/5/19/23126349/glitch-fastly-acquired-coding-anil-dash-fog-creek

https://github.com/fossmo/awesome-zettelkasten

A curated list of zettelkasten resources

This is where I think Glitch goes wrong. Why such a focus on apps (and esp. pushing the same practices and overcomplicated architecture as people on GitHub trying to emulate the trendiest devops shovelware)?

"Web" is a red herring here. Make the Web more accessible for app creation, sure, but what about making it more accessible (and therefore simpler) for sharing simple stuff (like documents comprising the written word), too? Glitch doesn't do well at this at all. It feels less like a place for the uninitiated and more like a place for the cool kids who are already slinging/pushing Modern Best Practices hang out—not unlike societal elites who feign to tether themself to the mast of helping the downtrodden but really use the whole charade as machine for converting attention into prestige and personal wealth. Their prices, for example, reflect that. Where's the "give us, like 20 bucks a year and we'll give you better alternative to emailing Microsoft Office documents around (that isn't Google Sheets)" plan?

See also An app can be a home-cooked meal along with this comment containing RMS's remarks with his code-as-recipe metaphor in the HN thread about Sloan's post:

some of you may not ever write computer programs, but perhaps you cook. And if you cook, unless you're really great, you probably use recipes. And, if you use recipes, you've probably had the experience of getting a copy of a recipe from a friend who's sharing it. And you've probably also had the experience — unless you're a total neophyte — of changing a recipe. You know, it says certain things, but you don't have to do exactly that. You can leave out some ingredients. Add some mushrooms, 'cause you like mushrooms. Put in less salt because your doctor said you should cut down on salt — whatever. You can even make bigger changes according to your skill. And if you've made changes in a recipe, and you cook it for your friends, and they like it, one of your friends might say, “Hey, could I have the recipe?” And then, what do you do? You could write down your modified version of the recipe and make a copy for your friend. These are the natural things to do with functionally useful recipes of any kind.

Now a recipe is a lot like a computer program. A computer program's a lot like a recipe: a series of steps to be carried out to get some result that you want. So it's just as natural to do those same things with computer programs — hand a copy to your friend. Make changes in it because the job it was written to do isn't exactly what you want. It did a great job for somebody else, but your job is a different job. And after you've changed it, that's likely to be useful for other people. Maybe they have a job to do that's like the job you do. So they ask, “Hey, can I have a copy?” Of course, if you're a nice person, you're going to give a copy. That's the way to be a decent person.

Interesting that this is written by a BSD guy.

(NB: this is in response to the question Why not just use wordpress + wysiwyg editor similar to *docs, and you're done?.)

This is a good of an explanation as any for local-first software.

A natural response (to potatolicious's comment) is, "Well, somebody has to maintain these no-code Web apps, too, right? If there's someone in the loop maintaining something, the question still stands; wouldn't it make more sense for that something to be e.g. a WordPress instance?"

Answer: yeah, the no-code Web app model isn't so great, either. If service maintenance is a problem, it should be identified as such and work done to eliminate it. What that would look like is that the sort of useful work that those Web apps are capable of doing should be captured in a document that you can copy to your local machine and make full use of the processes and procedures that it describes in perpetuity, regardless of whether someone is able to continue propping up a third-party service.

I learned the techniques programmers use to tame complexity: things like factoring, levels of abstraction, and separation of concerns.

with one foot in the design world and one foot in the programming world, I wondered if we could apply these software development principles to the way we designed and managed the product.

It's not nearly as timeless as a person might have themselves believe, though. (That's the "predilection" for certain technologies and doing things in a certain way creeping in and exerting its influence over what should otherwise be clear and sober unbiased thought.)

There's basically one timeless API, and that means written procedures capable of being carried out by a human if/when everything else inevitably fails. The best format that we have for conveying the content comprising those procedures are the formats native to the Web browser—esp. HTML. Really. Nothing else even comes close. (NB: pixel-perfect reproduction à la PDF is out of scope, and PDF makes a bunch of tradeoffs to try to achieve that kind of fidelity which turns out to make it unsuitable/unacceptable in a way that HTML is not, if you're being honest with your criteria, which is something that most people who advocate for PDF's benefits are not—usually having deceived even themselves.)

Given that Web browsers also expose a programming environment, the next logical step involves making sure these procedures are written to exploit that environment as a means of automation—for doing the drudge work in the here and now (i.e., in the meantime, when things haven't yet fallen apart).

There's an unnecessary dichotomy here between uses JS and page is served as HTML. There's a middle ground, where the JS can do the same thing that it does now, but it only does so at edit time—in the post author's own browser, but not in others'. Once the post author is ready to publish an update, the client-side generated content is captured as plain HTML, and then they upload that. It still "uses JS", but crucially it doesn't require the visitor to have their browser do it (and for it to be repeated N times, once per page visit)...

I dunno. Was the wiki software in question MediaWiki?

I always thought it was weird when people would set up a wiki and'd go for something that wasn't MediaWiki (even though I have my own quibbles with it). MediaWiki was always the clear winner to me, even in 2012 without the benefit of another 10 years of hindsight.

Types of requirements in a SaaS selection

There are different types of requirements. In this article we divide the requirements into a number of categories that help us with the software selection.

Kartik made a similar remark in an older version of his mission page:

Open source would more fully deliver on its promise; are the sources truly open if they take too long to grok, so nobody makes the effort?

https://web.archive.org/web/20140903010656/http://akkartik.name/about

I don't think so. I think it's rather the opposite. Churn is one of the biggest causes for what makes modifying software difficult. I agree, however, with the later remarks about making it easy to delete code where it's no longer useful.

Likewise, a program being written (especially one being written anew instead of by adapting an existing one) should be written in terms of capabilities from the underlying system that make sense for the needs of the greater program, and not by programming directly against the platform APIs. In the former case, you end up with a readable program (that is also often portable), whereas in the latter case, what you end up writing amounts to a bunch of glue between existing system component that may not work together in any comprehensible way to half the audience who is not already intimately familiar with the platform in question, but no less capable of making meaningful contributions.

I have learnt to abandon such attempts of adaptation fairly quickly, and to start the design of a new program according to my own ideas and standards

Feature request (implement something that allows the following): 1. From any page containing a bookmarklet, invoke the user-stored bookmarklet בB 2. Click the bookmarklet on the page that you wish to be able to edit in the Bookmarklet Creator 3. From the window that opens up, navigate to a stored version of the Bookmarklet Creator 4. Invoke bookmarklet בB a second time from within the Bookmarklet Creator

Expected results:

The bookmarklet from step #2 is decoded and populates the Bookmarklet Creator's input.

To discriminate between invocation type II (from step #2) and invocation type IV (from step #4), the Bookmarklet Creator can use an appropriate class (e.g. https://w3id.example.org/bookmarklets/protocol/#code-input) or a meta-based pragma or link relation.

Bookmarklets and the JS console seem to be the workaround.

For very large customizations, you may run into browser limits on the effective length of the bookmarklet URI. For a subset of well-formed programs, there is a way to store program parts in multiple bookmarklets, possibly loaded with the assistance of a separate bookmarklet "bootloader", although this would be tedious. The alternative is to use the JS console.

In FIrefox, you can open a given script that you've stored on your computer by pressing Ctrl+O/Cmd+O, selecting the file as you would in any other program, and then pressing Enter. (Note that this means you might need to press Enter twice, since opening the file in question merely puts its contents into the console input and does not automatically execute it—sort of a hybrid clipboard thing.) I have not tested the limits of the console input for e.g. input size.

As far as I know, you can also use the JS console to get around the design of the dubious WebExtensions APIs—by ignoring them completely and going back to the old days and using XPCOM/Gecko "private" APIs. The way you do is is to open about:addons by pressing Ctrl+Shift+A (or whatever), opening or pasting the code you want to run, and then pressing Enter. This should I think give you access to all the old familiar Mozilla internals. Note, though, that all bookmarklet functionality is disabled on about:addons (not just affecting bookmarklets that would otherwise violate CSP by loading e.g. an external script or dumping an inline one on the page`).

There're lots.

It's weird that in 2021 this canard associated with conflating libre and gratis is still showing up.

Test cases, examples and Best Practices A test case is a series of actions that are performed to determine a specific function or functionality of your application. Test scenarios are rather vague and include a wide range of variables. However, testing is all about being very specific. That is why we need elaborate test cases.

motivated by profit?

• estas son las libertades de los wikis**

Application, System, Tool or Software, what is what? Application, System, Software and Tool, are different words that we often use to describe computerprograms that perform a task. These words have specific meanings in different contexts. IT.

I suspect VS Code's non-native look has actually contributed to the uptake from a subset of its users. A fullscreen terminal-based editor like Vim is also non-native as far as widget sets are concerned, but pleasantly so in at least one respect. When Chrome was released, when you asked people what they liked about it, sure they'd say it was fast and whatnot, but for a non-trivial segment of the world, they just liked how visually slim it was. They appreciated how little chrome was actually in Chrome. VS Code managed to reap dividends on its imports of the same approach to its "shell", even while not being particularly fast. (People point to VS Code as an example of a snappy Electron app, and they're not wrong insofar as the comparison goes to other typical Electron apps; on an absolute, non-weight-class-adjusted scale, though, VS Code is still pretty clunky—people just ignore it because of how slim it appears in comparison to IDEs like MonoDevelop[1].)

1. https://upload.wikimedia.org/wikipedia/commons/0/01/Monodevelop-main-window.png

Meanwhile, not only does the scope of this tool not merit the Big Sur requirement, it doesn't even require a Mac. It interaction style is so free of intracies that it could be developed (and distributed) as a single HTML file with a text input and some script blocks.

This tool should be a "codebook"—a downloadable document meant to be stored in an offline copy e.g. on the user's local disk, a la PDF (except still actually HTML, as here). I shouldn't need to "go to" anywhere to use it; that should only be necessary to get it the first time.

This reminds me of physical tinkering, like building or fixing your own small furniture. That's also hard with the products we often buy today -- it's difficult to fix minature electronics which are meant to be replaced.

But with software (esp. open source) it could be easier, as everyone can have the same tools. I very much resonate with the idea of tinkering more and using less standards.

STLC - Software Testing Life Cycle

Software Testing Life Cycle (STLC) is defined as a set of activities performed to perform software testing. The Software Testing Life Cycle refers to a testing process with specific steps that must be performed in a specific order to ensure that quality objectives are met.