-
How hard would it be to make these without the Alexandria dependency? (I’d try it myself but just don’t have the time and energy currently.)
-
with-gensymsis trivial to replace.parse-bodywould be tougher, but still isn’t too bad.
-
-
Bonus points for
declare!Thanks @sjl. But now I miss Lisp even more. (And I also appreciate Lisp-2s!)
-
-
Always good to see more folks getting into Common Lisp!
As far as I can tell, new Quicklisp projects have to be located inside
${HOME}/quicklisp/local-projects. I am not particularly happy with it, but it is not really important.If you want to put your projects elsewhere on your disk, you can put symlinks into
local-projectsthat point to them. I even have allpshell alias (“Link in Local Projects”) to run something likeln -s "$(pwd)" "$HOME/.quicklisp/local-projects"to make it easy to add the symlink (note that I keep quicklisp in~/.quicklispso it doesn’t clutter the file listing), since I do it so often.I had already installed clisp, and it took me quite some times to understand my mistake.
I will always be annoyed at clisp for choosing such a confusing name.
Quicklisp packages (systems?) are defined through asd files.
Common Lisp’s terminology is confusing because it’s old and uses a lot of words that we use now (like “package”) to mean different things than people mean today. Things get easier once you internalize what Common Lisp means by the terms.
A package in Common Lisp is a container for symbols. They’re a way to group related names (symbols) together so you don’t have to do the miserable prefixing of every name with
mylibrary-...like you do in Emacs Lisp or C to avoid name clashes.Unlike other languages like Python/Clojure/etc, packages and files on the hard disk are not tied strongly together in Common Lisp. You can have several files that all work with the same package, a single file that switches back and forth between packages, or even write code that creates/mutates packages at runtime. Files and packages are orthogonal in Common Lisp, which gives you maximum flexibility to work however you want.
A system in Common Lisp is a collection of code (mostly) and a description of how to load that code (and some metadata like author, license, version, etc). For example: my directed graph library
cl-digraphcontains a system calledcl-digraph. That system has a description of how to load the code, and that description lives in thecl-digraph.asdfile. It creates a Common Lisp package (calleddigraph).The Common Lisp language itself has no knowledge of systems. ASDF is a Common Lisp library bundled with most (all?) modern implementations that handles defining/loading systems. (The name stands for Another System Definition Facility, so as you might guess there have been several other such libraries. ASDF is the one everyone uses today.)
Systems and packages are orthogonal in Common Lisp. Some systems (like small libraries) will define exactly one package. Some systems will define multiple packages. Rarely a system might not define any new packages, but will use or add to an existing one.
A project in Common Lisp is not an official term defined anywhere that I know of, but is generally used to mean something like a library, a framework, an application, etc. It will usually define at least one system, because systems are where you define how to load the code, and if it didn’t define a system how would you know how to load the code? My
cl-digraphlibrary mentioned above is a project that defines three systems:-
cl-digraphwhich contains the actual data structure and interface. -
cl-digraph.testwhich contains the unit tests. This is a separate system because it lets users load the main code without also having to load the unit test framework if they’re not going to be running the tests. -
cl-digraph.dotwhich contains code for drawing the directed graphs with Graphviz. This is a separate system because it lets users load the main code without also having to load thecl-dotsystem (the graphviz bindings) if they don’t care about drawing.
If I were writing this today I’d use ASDF’s
foo/barsystem naming notation instead of separating the names with a dot, because there’s some nice extra support for that. I just didn’t know about it at the time, and don’t want to break backwards compatibility now.We saw how Common Lisp has no concept of a system — that comes from ASDF. Similarly, ASDF has no concept of the internet, or reaching out to somewhere to download things. It assumes you have somehow acquired the systems you want to load, maybe by sending a check to an address and receiving a copy of the code on floppy disk, as many of my old Lisp books offer in the back pages.
Quicklisp is another library that works on top of ASDF to provide the “download projects from the internet automatically if necessary” functionality that people want in our modern world. So when you say
(ql:quickload :cl-digraph)you’re asking Quicklisp to downloadcl-digraph(and any dependencies) if necessary, and then hand it off to ASDF to actually load the code of thecl-digraphsystem. Unlike ASDF, Quicklisp is relatively new in the Common Lisp world (it’s only about eight years old) bundled with any modern Lisp implementations (that I know of) (yet?), which is why you need to install it separately.So to summarize:
- Files are files on your hard drive.
- Packages are containers of symbols. They are orthogonal to files.
- Systems are collections of code, plus instructions on how to load this code. They are orthogonal to packages.
- Projects are high-level collections of… “stuff” (code, documentation, maybe some image assets, etc). They are (mostly) orthogonal to systems (seeing a trend here?).
- Common Lisp knows about files and packages. ASDF adds systems. Quicklisp adds the internet.
This is a pretty high-level view that glosses over a lot, but maybe it’ll clear things up and help you dive into the details later.
-
-
Do you also code in Python? I tried out common lisp for a short while and then decided that Python gave me all this power and more without some of the strangeness. I did like that Common Lisp could be compiled (and that there is a decompiler right there in the REPL) but all in all, I came away underwhelmed. I supposed I had been set up for that by the mythology round CL.
I’m going to follow your further journey with interest to see how you like it in comparison to a modern dynamic language, like Python or Ruby.
-
The mythology definitely has done Common Lisp (CL) no good, especially all the mindless advocacy of people on the orange website in the years past. Oftentimes I wondered if they even used CL or were just repeating what others said.
That said, CL is still my favorite language because it makes most things so effortless. It doesn’t force one into a specific paradigm and one doesn’t have to remember all kinds of strange syntax rules (which can be a problem if you switch between different languages a lot).
I’m curious what you meant with “strangeness” ?
I do not feel Python or Ruby are more modern. They do have a more expansive community and libraries but what is more modern about them?
-
I forget the details, but one thing that stuck out was that there was all this todo about how code was data, and yet when you went to call a variable as a function you had to use
funcallrather than just do it “normally”. I also found it hard to read: I had to rely on indentation, and then the parens got in the way.I can see how CL was spectacular in the 1970s. But today we have Python, which has a REPL, introspection, monkey patching, good debuggers and many, many libraries often high quality ones that people have “standardized” upon. I do miss some form of compilation, which is what, to me, was a good thing about CL, as well as the gradual typing you could do (I think).
-
-
The key differentiator for LISP/Scheme was that one can easily customize the language to make their problem easier to express. You break your problem downward into simpler sub-problems while using macros to bring the language upward toward easily expressing your solution. The ability to change how things work can save lines of code, make portability easier, make optimizations easier and so on. The language itself being so malleable means you don’t have to use external tooling like another language or redo your compiler/interpreter to achieve those gains.
Python has quite a bit of power. It’s been a while since I used it. Can it currently define or redefine language features on a per-program basis using code not that different from regular Python?
-
Hi!
Yes, so I bailed before I learned macros. Probably makes my opinions on CL invalid.
I saw one or two examples of macros (DSLs). They were mind blowing, but also disturbing. The danger I saw was that I could make my code unreadable by other people, including my future self because of the freedom afforded.
@aerique says “one doesn’t have to remember all kinds of strange syntax rules” but with macros now every one and their grandfather have their own syntax rules.
I have some confidence going into a Python code base that I will understand the intent of the coder by following the code as it is written down.
With CL macros I felt that I would be having to go much deeper into the writers mind to understand the code.
As it is, I have issues with the amount of malleability I get from Python.
-
Good guess. That is a problem if macro use is undisciplined. What I recommend is using regular, boring primitives for most of the code with macros only where justified. From there, macros are much like libraries where you usually just need to know how to use them rather than their internals.
If you ever want to try it, How to Design Programs with Racket Scheme is widely recommended to learn both Scheme and their programming approach. It’s free online.
-
-
-
-
Firstly, yes, some pretty bad mistakes here.
Secondly, if it’s as easy to fix as OP makes out then he/she could have submitted a PR instead of writing a blog post. That would have actually got the message to the right people.
-
Not quite a PR but there has been an issue for it since 2016 https://github.com/Microsoft/microsoft-r-open/issues/20
-
-
I did a quick google but couldn’t find the article about it, but I’m missing a “project status” line. Which indicates whether the project is actively being developed, in maintenance mode, abandoned, etc.
-
hopefully this will get a bunch of FOSS projects off github. they should never have been on there in the first place.
-
-
I used to host everything on Gitorious. It was around since slightly before GitHub, but then got aquired by GitLab and shut down. It looks like everything was migrated over to GitLab some time later, but by then I was happily self-hosting bare clones with a static file server.
-
-
-
Who are you to tell open source maintainers where they “should” be?
If you believe it’s important that open source projects need to use open source tools, you need to start by making the open source tools great, not by lecturing people for using effective tooling to advance their projects.
-
maintainers of free software should use free tools to support the free software ecosystem, and so that others don’t have to give away their freedom in order to participate. you seem to be implying that the only valid criterion for using a tool is how “effective” it is in the short term; i don’t agree with that.
-
-
-
-
zziqododzasi
3 months ago
|
link
| on:
Privacy Tool uBlock (NOT uBlock Origin) Adds User Tracking Feature
Ouch, capitalizing on name confusion? That’s not very cool. I wish uBlock origin would do a name change that would keep them from being confused with uBlock.
-
-
-
Yeah, but when changing the name uBlock Origin has the chance to also claim all other alternative names as well.
-
-
-
-
I love how that 28 year old Common Lisp code looks pretty modern still and should run on most implementations without (too m)any changes.
-
What’s the meaning of the last line, “I showed up for him”?
-
As used here, “him” implicitly means more than just “Steve Jobs.” It alludes to the essence of Jobs, the things that make him who he is. Carmack is saying he dropped everything he was working on when Jobs asked for him because of his admiration and respect for Jobs’ as a person, not just for Jobs’ fame or influence. Sentences like these are frequently written with “him” italicized, and spoken with strong emphasis on “him.”
That’s how I read it anyway.
Sorry if my explanation seems patronizing, I just went ahead and assumed you’re a non-native English speaker.
-
-
-
Hmm, the key argument here seems to be that idiomatic Lisp uses untagged general-purpose datatypes (like lists or tuples) more than idiomatic usage of other dynamic languages like Python or Ruby does. That doesn’t mesh with my own experience. My experience of Common Lisp, at least, is that people usually use a lot of defstruct and defclass (this may not be true in elisp or Scheme). My experience with Python, meanwhile, has been that it’s extremely common to just use tuples/lists/dictionaries for absolutely everything (or in numerical code, NumPy arrays), and not to define classes, especially in user-level code. But neither I nor this article have any actual data on what is typically used in either language, so it’s kind of duelling anecdotes.
-
In Common Lisp (CL), especially at the begin of a project in the exploratory phase I use (and might even overuse) property lists (plists) a lot in favor of structs and classes because they’re so convenient: they’re easy to change and very clear on the REPL, during debugging and printing.
Here is what a plist looks like CL both in the code (input) as in the output:
(:id 123 :name "Herman Zersteurer" :balance 456.789)One can access or modify elements with GETF:
> (getf plist-variable :name) "Herman Zersteurer"
-
-
Take this as constructive criticism, but when I see “for all languages”, I’m immediately skeptical, and then annoyed when the languages I’m interested in aren’t supported. Saying “Linting and fixing code for tons of languages” sounds just as good, and is more honest.
-
I do see your point but when coala was started the goal was to have one liter interface to unite them all. We are constantly working towards extending support for more languages by adding more linters to our list. If you don’t see the languages you want supported by coala then you can make an issue over here: https://github.com/coala/coala-bears/issues
Btw which languages did you not find support for?
-
Just a data point: Quickly searching through the Languages section for “Lisp” (Common Lisp) or “Scheme” doesn’t turn up anything.
I’m somewhere in-between on the “all languages” thing. I prefer tools that cover a lot of ground while being good enough, but it’s hard to get to the good enough state.
-
-
-
-
Emacs Lisp has many features of Common Lisp, although it is considerably smaller (and thus easier to master).
Ehn, sorta. Elisp is smaller, but as far as I can tell, the
cllibrary is used an awful lot, mostly because writing Elisp can be such a slog. I love Common Lisp (CL) and have used Emacs for 20 years now, and I’ve never been able to get into writing Elisp, although I’ve been trying more lately.It’s not because it’s terrible but because the APIs are so vast. Have you ever tried to read through the Elisp manual? You’ll be there for a long time (hint: understanding buffers is the Zen of Elisp, so jump ahead).
Also, Elisp doesn’t seem to encourage breaking things down into functions as much as CL. A lot of existing code that I’ve looked at has many little expressions that would be nicely served as predicates or one-off functions, but since Elisp doesn’t have something like
flet, the language doesn’t encourage such things. As a result, some functions are huge and really hard to follow. One great thing about Emacs is how easy it is to examine the code for things; it’s too bad that code is so obtuse a lot of the time.-
Yup, rms famously doesn’t like Common Lisp’s complexity, but I think that the histories of both elisp & Scheme are used in practice demonstrate the wisdom of Common Lisp’s approach. As an example, elisp has no namespacing mechanism, so folks commonly prepend the package name to variables & functions, leading to variables named e.g.
my-package-variable& internal variables named e.g.my-package--private-variable; one has to type those long names everywhere, even in the package defining them, or a package which heavily uses them; in Common Lisp one would have a packagemy-package& the variables could be referred to asvariable&private-variablewithin the package, and asmy-package:variable&my-package::private-variableexternally, or asvariableinside a package usingmy-package. Complex? Certainly: I had to write a lot of words there, and maybe the reader doesn’t quite follow. A good thing? Yes, it’s easily learnt and it pays for itself every single time one writes or uses a package.I can only imagine how awesome emacs would be today had it switched to Common Lisp back in the early 90s.
-
-
You are correct, it does not have a language-defined namespace mechanism. That’s done with function naming conventions. It does have a package system, but that’s for feature distribution.
-
-
-
-
-
Ha, nice! I was recently looking for a tool that could plot on the CLI as well. I came across bashplotlib but failed at Googling and didn’t find the others mentioned on this page and I fell back to gnuplot’s term mode.
I’ve always liked CLI tools although I use GUIs as well, but I’ve come to realize that the CLI is not something to be superseded by GUIs. They are different ways of interfacing with a computer and can exists side-by-side and so I’m happy to see new tools being created for it.
-
If I move off of OS X, it will be to Windows. For what I use my machine for, the applications simply aren’t there on any Unix other than OS X.
-
I’ve been using Linux as my main desktop since about 3 years and used all of the major desktop environments. KDE Plasma looks good but either its file indexer (
baloo) is taking hostage of one CPU core or the desktop crashes if you type specific words or too fast in the launcher, in short a horrible experience. I used Gnome for about a year and it was not much better, the plugins/extensions are often buggy and especially under wayland it crashes often and can’t restart like on X11, i.e. you loose all of your session state. Additionally, it feels laggy even on a beefed out machine (6 cores, latest gen. AMD GPU) because the compositor is single-threaded. GDM, gnome’s display manager, is also sluggish, runs since gnome 3.26 a process for each settings menu and starts a pulseaudio session which breaks bluetooth headset connections. Also unsuable for a productive environment in my opinion. Eventually I switched back to the desktop environment with what I started my Linux journey, namely XFCE with lightdm as a display manager. Withcomptonas compositor it looks quite okay, is rock solid (in relation to the other DE I used) and everything feels snappy. As a note, I run all of the DEs on Arch Linux and I haven’t even talked about display scaling and multi-monitor usage, still a horror story.TL;DR The year of the Linux desktop is still far away in the future.
-
I wouldn’t really know where to go. I have an Arch desktop at home (quad Xeon, 24 GB RAM, 2 SSDs), while the machine is much faster than my MacBook Pro, I usually end up using the MacBook Pro at home (and always at work), simply because there are no equivalents for me for applications like OmniGraffle, Pixelmator/Acorn, Microsoft Office (project proposals are usually floated in Word/Excel format with track changes), Beamer, etc. Also, both at work and home, AirPlay is the standard way to get things on large screens, etc.
Also, despite what people are saying. The Linux desktop is still very buggy. E.g. I use GNOME on Wayland with the open amdgpu drivers on Arch (on X I can’t drive two screens with different DPIs). And half of the time GNOME does not even recover from simple things like switching the screen on/off (the display server crashes, HiDPI applications become blurry, or application windows simply disappear).
Windows would probably have more useful applications for me than Linux or BSD (since many open source applications run fine on WSL). But my brain is just fundamentally incompatible with any non-unix.
-
Linux has been my main desktop for 20 years or so? Although I am a software developer and either do not need the applications you mentioned or use alternatives.
Anyway, what I actually wanted to say: on the hardware side I’ve had little issues with Linux, certainly not more than with Windows or OS X and at least with Linux (if I put the time into it) the issues can generally be fixed. I’ve been running multiple monitors for years and hibernation used to be a pain in the ass in the early 2000’s but has been good for me on a wide array of hardware for years (definitely better than both Windows and OS X which run on supported hardware!). Granted, I can’t blindly grab hardware off the shelf and have to do some research up front on supported hardware. But that’s what you get if hardware vendors do not officially support your OS and it does come with many upsides as well.
I run pretty bare systems though and try to avoid Window’isms that bring short-term convenience but also bring additional complexity, so no systemd, pulseaudio, desktop environments like Gnome for me. Still, I’m running Linux because I want to be able to run Dropbox (actually pCloud in my case), Steam, etc.
-
Linux has been my main desktop for 20 years or so?
Different people, different requirements. I have used Linux and BSD on the desktop from 1994-2007. I work in a group where almost everybody uses Macs. I work in a university where most of the paperwork is done in Word (or PDF for some forms). I have a fair teaching load, so I could mess around for two hours to get a figure right in TikZ (which I sometimes do if I think it is worth the investment and have the time) or I could do it in five minutes in OmniGraffle and have more time to do research.
It’s a set of trade-offs. Using a Mac saves a lot of time and reduces friction in my environment. In addition, one can pretty run much the same open source applications as on Linux per Homebrew.
I do use Linux remotely every day, for deep learning and data processing, since it’s not possible to get a reasonable Mac to do that work.
Anyway, what I actually wanted to say: on the hardware side I’ve had little issues with Linux, certainly not more than with Windows or OS X and at least with Linux (if I put the time into it) the issues can generally be fixed.
The following anecdote is not data, but as a lecturer I see a lot of student presentations. Relatively frequently, students who run Linux on their laptops have problems getting projectors working with their laptops, often ending up borrowing a laptop from one of their colleagues. Whereas the Mac-wielding students often forget their {Mini DisplayPort, USB-C} -> VGA connectors, but have no problems otherwise.
-
-
-
Same. I don’t use them every day, but I do need Adobe CS. I also want (from my desktop) solid support for many, many pixels of display output. Across multiple panels. And for this, Windows tends to be better than Mac these days.
-
-
One thing I’m finding is that a lot of Mac apps I rely on have increasingly capable iOS counterparts (Things, OmniOutliner, Reeder, etc.) so I could potentially get away with not having desktop versions of those. That gets me closer to cutting my dependency on macOS, though there’s still a few apps that keep me around (Sketch, Pixelmator) and the ever-present requirement of having access to Xcode for iOS development.
-
-
I don’t really understand the goal of this. OpenBSD is supposed to be used for it’s security (mainly) or simplicity, but what’s the goal of it for machine learning?! I mean, everybody admits that OpenBSD is definitely slower than many linux distributions and ML seem to be an abyss for CPU/RAM resources. Maybe this is just for fun, but it seems like an useless constraints to me…
-
-
If you were doing ML for real, you’d probably be using a GPU/TPU. Or a distributed system (as e.g. in neuroevolution). Which makes OpenBSD a suboptimal choice.
However, if you’re just doing it on the CPU & system RAM, it’s basically all pure compute, so the speed of the operating system does not really play a role (unless you’ve got so many cores that scheduling becomes a problem). The speed of the OS only becomes relevant when you’re heavily involving the kernel (and perhaps the allocator), which you don’t in pure compute.
It’s just for fun.
-
If you were doing ML for real, you’d probably be using a GPU/TPU. Or a distributed system (as e.g. in neuroevolution). Which makes OpenBSD a suboptimal choice.
I think this is a serious misconception about machine learning. The majority of machine-learning applications probably can run on a single PC (potentially your laptop if it has enough RAM).
-
The majority of machine-learning applications in use today? No doubt, they are constrained by the resources that we have today. The pressure to go bigger and deeper is there and deep networks have shown so much promise. Training overnight, or for days or even weeks is no fun. And yet the fact that we even can train such deep networks at all within such a “reasonable” timeframe is what drives the current AI hype cycle.
If you have an useful source from which I can learn why the majority of machine-learning applications are not constrained by performance, I’d be interested.
-
-
-
-
If it’s for a corporation I presume it’s so he can hack it up without having to share source.
-
-
It’s not pessimistic, it’s what a lot of people hack on BSD for and its honestly part of what the license was designed for. The fact that you clarified that it’s not to open source means he might have a quiet closed source ambition for it. It’s not unreasonable to presume because he picked the platform which legally permits a behavior, that it might contribute to why he picked it.
-
-
Ah that clarifies a lot. He’s just using it as his os. I normally would RTFA but facebook. I wasn’t trying to paint them in a negative light though yes definitely from a more OSS passionate perspective that would be negative.
-
-
-
-
-
-
Longtime user of StumpWM here. I really enjoy using it; it’s very nice to be able to easily extend my window manager while it’s running, and to have a complete Common Lisp environment always available. Highly recommended.
-
I’ve been using i3 for years but recently came back to StumpWM because Common Lisp is my favorite language. Going from i3 to StumpWM is a small step (there’s some advantages in both of them compared to the other) and I haven’t run into major issues the last couple of weeks. It is also stable.
So, recommended as well!
-
-
My only problem is that [StumpWM] only supports bitmap fonts …
Luckily, that’s not true. I’m using TrueType with StumpWM just fine.
Just get ttf-fonts & then throw this at the top of your config:
(ql:quickload '(#:clx-truetype #:ttf-fonts)) (set-font (make-instance 'xft:font :family "Source Code Pro Semibold" :subfamily "regular" :size 12))(changing the args as you like — I find that Source Code Pro is an awesome font)
-
-
-
-
Interestingly, my argument why I don’t like macros goes somewhere along those lines: If you have something repetetive where people use macros to work around, it’s probably a flaw in the host language.
I’m not saying they are bad, just that I don’t like them.
Excluded are obviously languages that are fundamentally based on them.
-
-
Possible outcome: every project works around the problem in their own slightly incompatible way, and no-one bothers fixing the problem in the host language because it’s easy enough to work around.
I like macros as a way to cheaply prototype proposed language changes. I don’t want to see them in production code; debugging from the output of a (nonstandardised) code generator is awful but still easier than debugging from the input, which is effectively what the choice between code generation and macros boils down to.
-
I like macros as a way to cheaply prototype proposed language changes. I don’t want to see them in production code; debugging from the output of a (nonstandardised) code generator is awful but still easier than debugging from the input, which is effectively what the choice between code generation and macros boils down to.
This has, by the way, happened with Rusts “try!()” (which, after some modifications, became the “?” operator).
-
Reminds me of Rust’s primary use of macros: emulating the varargs that the language lacks.
My cardinal rule about macros is that if I have to know that something is a macro, then the macro is broken and the author is to blame.
Rust also messed up in that regard by giving macro invocations special syntax, which acted as an encouragement to macro authors to go overboard with them because “the user immediately sees that it is a macro” – violating the cardinal rule about macros.
-
-
Yup, the alternatives are duplication/boilerplate or external codegen until the language catches up. Macros are an decent way to make problems more tractable in the short term (unless your in a wonderous language like Racket), or even to prototype features before they are implemented in the full language. I’d love to see more metaprogramming with a basis in dependant types, but alas there’s still lots of work to be done before that has been made workable for the average programmer.
-
Sure, that’s why I said they aren’t bad, I just don’t like them.
On the other hand, I also don’t have any problem with codegen over macros, its basically the same thing at another phase.
-
-
Say that this flaw is becoming obvious a couple of years after the language’s release. In that case the fix may have the consequence of breaking some subset of existing code which is arguably worse than including macros in the language. I don’t know where I want to go with this strawman-like argument other than to say that language design is hard and macros lets the users of the language make up for the designers deficiencies.
-
I totally appreciate that. I just don’t see “does the language have macros” as the issue people make it. For example, languages with very expressive metaprogramming systems like Ruby have purposefully not included macros and are doing fine.
Macros are often an incredibly complex and problematic fix for this, though. Just the patterns list of the Rust macros book is huge and advanced: https://danielkeep.github.io/tlborm/book/pat-README.html
(Other languages have nicer systems, I know, but the issue persists: textual replacement is a mess)
I totally see their place, for example, we couldn’t define a type checked
println!("{:?}", myvalue)in Rust proper without adding a lot of additional things to the language.
-
-
-
Just got an email internally telling us the password expiration window has been reduced from 180 days to 90 days. There’s no use sending this article to the powers that be internally, somewhere there’s a checkbox in a security window dressing form that requires 90 days expiration and that’s what it’s going to be.
-
It’s doubly awful when you have a couple of disjoint authentication domains, say an AD arena and a UNIX one, and they have inconsistent expiration periods, length & complexity requirements, and reuse policies.
Best of all are the systems where you can’t change your password until it expires, thus making it impossible to keep in sync with other domains.
-
I wonder how many of these “best practices” are simply word-of-mouth beliefs handed down from management to management with little control over exactly how well they’re sourced.
Oh well next password change here will be a passphrase. I’ve been relying on a little C program that generates nicely pronounceable passwords but it’s time to uppgrayed I think.
-
-
-
Having tried various mechanical and / or split keyboards with different kinds of switches over the years[1] I keep coming back to to the Apple A1243 keyboard. It’s cheap (not really a requirements for me, but makes it easy to replace) and I like its feel the best. (And I’m far from an Apple advocate!)
Currently I’m actually using a Topre Realforce since those were still on my list to try out, but I don’t like the experience much better than the aforementioned A1243 keyboard. So, given the price, I would chose the latter.
[1] Including the TypeMatrix mentioned on this page.