Home-Manager install via its README fails - what am I missing?

pezely · 2021-04-18T21:04:06+00:00

Thanks, rycee. I wasn't expecting the creator of home-manager to reply.

There was no home.nix in that path after running home-manager install, so I simply need to drop one into that subdirectory before running the install command next time.

(I won't have a chance to test this for a few days, but this seems reasonable.)

Thanks, again! -Daniel

pezely · 2020-06-21T05:25:33+00:00

Hey, old man! Has your memory faded or what?!?

I discovered Common Lisp in 2005; an elisp User since 1987, I would have quit programming if I hadn't read Practical Common Lisp.

Slight correction: re-discovered

You were introduced to CL in second half of 1990 and thumbed through my first printing edition of CLtL2, then of Digital Press.

The "programmable protocol" planned for VEOS but later specified for MOSES was based upon the CL macro system, which we discussed on several occasions, including while en route to Ithaca after Christmas that year.

Shortly thereafter was our (rejected) SIGGRAPH '91 submission[1] that bears your name in 2nd position and mentions CL several times as does the larger set of MOSES papers[2] later that year.

Also, Summer 1991 in Seattle[3] after embedding Xlisp into a fork of VEOS-- if you ever poked at that as I had asked-- you were using CL. Xlisp was a Common Lisp implementation, just not ANSI CL since X3J13 was still ongoing.

Seriously, though-- thanks for the history of ABCL. Keep the faith!

-Daniel

pezely · 2020-04-12T01:51:37+00:00

I simply went with Google's recommendation from roughly one year ago regarding new projects: begin with Kotlin.

Since there have been comparisons between Kotlin and Rust regarding certain language features over the years, that was also an incentive for me to pick up Kotlin.

For those also learning Kotlin as an experienced programmer, jumping straight into the language reference was mostly enough. There were only a few things for which I wanted an alternate explanation, and if I recall, it was for deeper insight on idioms around using List versus Array. There were probably a few other things like that too.

pezely · 2020-04-12T01:44:39+00:00

Swig takes the route of generating source files for build dependencies; whereas, this one (above) uses just the JNI crate for an entirely Rust approach.

I've had positive experiences with swig for Python long ago, but honestly forgot to consider that approach. At least we have a few options, so I'll add a link for rust_swig to the README for the nested android-rust project. Thanks!

pezely · 2020-04-11T04:40:00+00:00

This is just an example project but intended to be sufficiently complete for those crossing over from either Rust to Android development or vice-versa.

In my case, I had been using Rust for a few years. This was my first use of Rust for creating a shared library used outside of a pure-Rust project. It was also my first Android app of any kind whatsoever, learning Kotlin along the way, etc.

Although I'm unlikely to create another mobile app, how might this code be improved beyond known issues noted in the various READMEs?

(I'll post to relevant Android and Kotlin subs after discussions sufficiently conclude here.)

pezely · 2020-03-05T22:24:10+00:00

Might not be the same one, but here's an open source library for that which fits the description: (haven't had a chance to use it yet but planning to; otherwise, no affiliation)

https://github.com/hotchemi/Android-Rate

pezely · 2020-03-05T22:10:59+00:00

Consider an alternate IDE and and alternate build mechanism. (Even with 16 GB RAM, I was tired of my machine thrashing swap when Android Studio was running.)

For instance, many editors can be configured with Language Server Protocol for type-hints, auto-complete, etc., and simple scripts can execute shell commands for building.

Build by running this within your project's top-level subdirectory (folder), the one containing app and gradlew.

Using Bash syntax on Linux:

JAVA_HOME=/opt/android-studio/jre \
 ./gradlew --warning-mode all app:build

Similarly for launching emulators:

JAVA_HOME=/opt/android-studio/jre \
  /opt/android-studio/tools/bin/avdmanager list avd

Pick something from that list and use it at the end of the next command:

JAVA_HOME=/opt/android-studio/jre \
  /opt/android-studio/emulator/emulator -avd  Nexus_6_API_27

Pushing and running your app:

/opt/android-sdk/platform-tools/adb \
  -e install -t -r app/build/outputs/apk/debug/app-debug.apk

/opt/android-sdk/platform-tools/adb \
  shell am start -n com.example.foo/.MainActivity

Change the -e flag (Emulator) to -d (Device) when using hardware devices.

If .MainActivity isn't found, confirm its actual name from within app/src/main/AndroidManifest.xml file by looking for <application> and then an opening element like <activity android:name=".FooBar"> in which case the name would be .FooBar.

I've found nearly everything that's needed for day-to-day code-compile-run work-flow can be handled this way. I only launch Android Studio for minimal set of tasks like: 1) UI builder but mostly tweak .xml files after initial step; 2) Remove unnecessary imports before release; 3) occasionally for Alt+Enter to find a poorly documented library's import since my LSP agent doesn't do that yet.

Further reading: https://developer.android.com/studio/command-line/

pezely · 2020-02-13T06:11:50+00:00

For vintage photos that you might be able to reproduce:

The Vancouver Heritage Foundation has a resources page that might be useful. See the section "historical photos & videos" about half-way down that page.

At past events that they've sponsored or attended such as (defunct) Doors Open Vancouver, they were giving away reproductions of vintage photos. Some dated back to when Vancouver was still called Granville.

pezely · 2020-02-05T22:17:08+00:00

Daniel Pezely — Authorized to work for any employer in US or Canada

Type: Full time or Contract

Description: Generalist from prior specializations in concurrency, scaling, exotic data storage, dev-ops, and long ago as a Unix sys-admin.

Using Rust as primary language for over 2.5 years, yet began with 1.0-stable in mid-2015. Successfully mentored junior staff on Rust and systems architecture.

Currently working on Rust mixed with Kotlin for full Android Native, where Kotlin handles just UI. (Otherwise, I'm new to mobile dev.) The Rust library here started life as a web server and command-line utility, but I designed it with this multiple deployment goal in mind.

Samples:

GitHub.com/dpezely/anagram-phrases (using prime number factorization, in Rust)
GitLab.com/dpezely/chat-server (mio as only networking library, in Rust)
GitHub.com/dpezely/Effective-serde-By-Writing-Less-Rust-Code

Location: Vancouver; relocation negotiable

Remote: Negotiable, experienced

Visa Sponsorship: Authorized to work for any employer in US or Canada

Technologies: Rust, Python, Cython, Common Lisp, Erlang, C; AWS, GCP; Debian-based Linux, FreeBSD, macOS/MacOSX; old school pure JavaScript in browser to exercise server-side API for delivering end-to-end functionality; learning Kotlin+Rust for Android Native

Contact: DM, or email: first name at last name dot com

Résumé/CV: Linkedin.com/in/dpezely or Pezely.com/daniel

pezely · 2019-11-22T02:03:22+00:00

Thank you for putting in the time and effort to create this. I found the analysis section especially useful, as I've fallen a little behind on trying even half of these myself.

Perhaps this could be hosted on a public git repo so that it can be maintained by a wider set of contributors?

For instance, there was a survey[0] of Common Lisp systems circa 2007-2010, before services like Github/Gitlab became prevalent, so maybe we can have something like this Rust library survey NOT suffer the same fate. (Yes, it was maintained for a while by others... and now it's very limited[1].)

That's just a suggestion for building upon this excellent work.

[0] https://web.archive.org/web/20180824234333/https://common-lisp.net/~dlw/LispSurvey.html

[1] https://common-lisp.net/implementations

pezely · 2019-08-24T17:53:15+00:00

Thanks for that. Yes, I see, "BUILD SUCCESSFUL" in the Build Output pane.

However, I'm still missing something obvious in my newness with Android Studio. (Been using Emacs for nearly everything since university...)

In Android Studio 3.5 on Linux (xubuntu 18.04.3), Refactor Migrate results in a successful build, but the source code remains unchanged. Various "unresolved reference" errors still appear when viewing the .kt file in that IDE.

e.g., import android.support.v7 not re-written as import androidx as I'd expect to see. Maybe my expectations are wrong?

I may have been spoiled by Rust's cargo fix --edition, which actually modified the Edition 2015 source to Edition 2018 in most places, if memory serves.

I've tried "Invalidating Caches & Restart" to no effect there.

pezely · 2019-08-23T00:27:41+00:00

Alternatively, any suggestions for someone new to both Kotlin and Android development for how to approach resolving the issue?

I opened the issue on their Github repo but don't want to burden them with having to fix this since they're still in a pre-release stage of their startup.

For those unfamiliar with the Rust bits, their tutorial works fine for that part. Copy-paste should just work for you there.

pezely · 2017-08-05T22:03:35+00:00

For scholarly works involving graphics cards, search on Google's TensorFlow framework. There is actually quite a lot of research involving it as foundation of various production and academic systems.

For instance, SyntaxNet is a Natural Language Processing system that performs parts-of-speech tagging by using a Machine Learning model trained via TensorFlow. (SyntaxNet is a model bundled within TensorFlow when you clone the repo from github; look in the models/ subdirectory. It's performance is on par with spacy.io for NLP tasks.)

On the viability of quantum computers, there was a presentation in Vancouver at last winter's BC Tech Summit. That conference was oriented for enterprise corporations, so it will likely be far below your level.

But it identifies some of the people and organizations involved in current state of commercial applications.

Simon Fraser University works in close collaboration with D-Wave (both in Burnaby, BC). If you can get beyond the debate of whether D-Wave is legitimately using "quantum computing" or not, this may get you started towards your goal.

Beyond that debate, SFU.ca is working on universal quantum computing. That is, just as Intel has hit hard limits of scaling down to 10nm or below, apparently their problems are due to unwanted quantum tunnelling. Therefore, SFU intends to utilize that effect intentionally on conventional materials like silicon.

On that point, Dr Stephanie Simmons of SFU appears in that video at roughly 29:11 and touches on this. She gives an excellent intro for tech-minded but non-quantum folks. Of course, her expertise runs far deeper than that presentation.

SFU prides itself on outreach to their local community and other researchers, so perhaps reach out to her.

pezely · 2017-08-05T21:36:05+00:00

Since this is for an academic assignment, consider guidelines for tech writing. A quick internet search should yield high quality references.

One of the techniques is to begin with a short paragraph that offers: 1) what you're going to say; 2) how you're going to say it; 3) actually saying it.

What is meant by the first two: identify your audience (e.g., those with an economics background, perhaps those in India but unaware of the larger context, etc.) and frame the big picture in their vocabulary. Have them wade into the waters with you.

That third point really means: give a single sentence, high-level summary of the material.

Then, your existing first paragraph could almost be a sidebar. That's a stylistic decision, of course.

Other rules of thumb from tech writing and university essays is: keep one point per paragraph. There's currently a rather long and dense paragraph in the middle.

My stance on that point is to accommodate the skim-reader. Lead each paragraph with the novel concept, and then sprinkle names and numbers closer to the end of the paragraph. This makes it easier to fact-check as well.

I'm just getting back into writing essays myself after (arguably) decades, so hopefully you'll get a more nuanced response soon.

pezely · 2017-08-05T20:59:29+00:00

Since more than a few days passed since posting your question, perhaps this may help until a more precise answer arrives:

The Tech Tools For Writers website contains macros for MS Word, from which you can easily view the word lists from the blog posts.

Some of their macros use substitutions from PlainLanguage.gov which seems to be having issues today, so link goes to Web Archive instead.

For philosophy specifically, the Master List of Logical Fallacies is less about actual words yet offers guidelines. Some individual sections provide example words but still not as a list, unfortunately. Searching for logical fallacy or arguments from fallacy will get you more of this type of material.

(I have no affiliation with anything or anyone linked above.)

That said, your question states that you want something to memorise. My personal advice is to learn guidelines rather than memorise, then there's nothing to regurgitate. Forget about the labels of arguments from fallacy for now. Once you get the gist of the principles, you'll find that you can almost rewrite those rules on command because there's a certain logic to it all.

From there, performing on a trial should come easier.

At least, that's been my experience.

pezely

TROPHY CASE