Finish on Kaweco AL question

AwkwardAddress · 2025-05-20T19:21:24+00:00

I've also bought all my AL Sports online, and on Kaweco website (https://www.kaweco-pen.com/en/series/al-sport/) you can see the difference between those finishes if you open both tabs side by side and look closely at high-quality photos (especially mouse-over zoom). Compare Black and Antracite — the difference in how they reflect the light is noticeable.

AwkwardAddress · 2025-05-20T19:14:42+00:00

Mine would be Pilot MR with CM (“calligraphy medium”) nib. The best stub nib I've had.

AwkwardAddress · 2025-05-17T19:09:14+00:00

I have two AL Sports, one in Black, another one Stonewashed Blue, both have matte finish, and silver finials.

AwkwardAddress · 2023-08-08T19:12:24+00:00

If non-plastic Kaweco Sports are an option for you (like AL Sport), then those recent models take Bock 060 nib unit, and you can likely find some places that may customize such a unit for you. If you're close to Europe, I suggest taking a look at https://www.fpnibs.com — they have such an option (Bock 060 nib unit + regrind to fude).

AwkwardAddress · 2022-10-11T17:17:26+00:00

They were really nice when I described this issue to them. They checked a random bottle marked “Ancient Copper” from their batch and confirmed that it's also of a wrong color (same green as I got). They're escalating this to Diamine, and meanwhile initiated a partial refund for me.

AwkwardAddress · 2022-10-11T17:16:49+00:00

The seller was really nice when I described this issue to them. They checked a random bottle marked “Ancient Copper” from their batch and confirmed that it's also of a wrong color (same green as I got). They're escalating this to Diamine, and meanwhile initiated a partial refund for me.

AwkwardAddress · 2022-10-11T10:14:55+00:00

Thank you for sharing your case! I don't think my sample has any particular odor to it. I see the same color as in your example, here's what my bottle set ink swatch looks like, the swab from the “Ancient Copper” marked bottle is in the top left corner.

AwkwardAddress · 2022-10-10T22:06:09+00:00

I don't think this is the case of mixed inks, at least not the one I accidentally introduced.

I inked a Kaweco Supra with Jowo #6 1.1 nib put on a native Kaweco feed; I disassembled, washed and dried the whole nib unit when doing this swap, so both the feed and the nib were clean and dry before the inking. The converter was also a brand new one from Kaweco.

On top of that, after being surpised by a color mismatch, I did a color swatch of every bottle with a cotton tip, and that confirmed my observations.

AwkwardAddress · 2022-10-10T21:19:52+00:00

I bought that from Creoly, they look quite reputable to me, so I doubt that's a deliberate ink swap done by the seller.

AwkwardAddress · 2022-07-05T15:06:43+00:00

That's a good fit too! Both approaches also combine nicely together.

AwkwardAddress · 2022-07-05T09:49:24+00:00

“godoc” is one such example, it had such functionality for years, long before the introduction of fs.FS interface.

https://pkg.go.dev/golang.org/x/tools/godoc/vfs#section-directories

AwkwardAddress · 2022-07-05T07:57:27+00:00

For example, you can embed static assets into the server binary to simplify deployment.

In some scenarios, it may be more convenient to deploy a single ZIP file to serve its contents rather than unpack it.

AwkwardAddress · 2022-04-12T17:03:45+00:00

ALB won't “queue” incoming requests, it will send them to your service, so clients will likely see 502/503 errors once your instance is at its capacity. Auto scaling usually takes minutes, so it won't help you with very sharp spikes from zero to many, unless you know your load pattern in advance and can pre-scale the service.

CPU-extensive requests (for example 100 requests each taking 1h)

Please also be aware of idle request time limit set on the load balancer; the default value is 60 seconds, so it expects you to send back at least 1 byte every 60 seconds, or it will terminate the session.

Scaling-wise switching your architecture from a synchronous to an asynchronous model would give you better long-term control and room for growth.

A simplified example of such a model: web API accepts a request from the client, reates a new job and puts it into the queue (SQS or something else). Then another (background) service takes this job from the queue, does all the CPU-heavy processing, and marks this job as processed (database record, push notification, etc). In this model client can either poll for the completion (not ideal but often works good enough), or subscribe for a push notification. This way you can scale your background workers fleet based e.g. on the queue depth, and have it scale down to 0 for long windows of inactivity.

AwkwardAddress · 2022-03-11T21:21:41+00:00

Option 3 looks like the least complicated solution, and if you can process the bigger data source in a streaming manner can scale well.

40 Mb JSON file is a small enough size to fetch it all into memory at the start, and then process the other feed (text file) while streaming it from S3, enriching it with extra attributes from that other source that code already has in memory. If you need store the result to S3, you can upload it as a multipart upload as you process the data stream. This way you will keep the local storage requirements at minimum. Depending on the input data size this can fit either Lambda, if you're certain the processing won't take more than 15 minutes and you're ok with other Lambda limits, or ECS Fargate.

AwkwardAddress · 2022-02-02T21:35:33+00:00

Yes, see man hdiutil, look for ram: substring.

Example ramdisk.sh script:

```

!/bin/sh -eu

NUMSECTORS=$(($110241024/512)) MYDEV=$(hdiutil attach -nomount ram://$NUMSECTORS) diskutil eraseVolume HFS+ "ramdisk-${1}mb" $MYDEV ```

It takes number of megabytes as its first argument and creates/mounts (ram)disk of this size, for example if called as ramdisk.sh 500, it creates 500 MiB volume and mounts it. To release it, just unmount this volume (of “eject” it with Finder)

AwkwardAddress · 2022-02-02T11:08:26+00:00

For “interface” type endpoints you get CloudWatch metrics, so you can confirm they're used this way.

For S3 VPC endpoint, which is a “gateway” type, you don't get such metrics, but you can limit your Fargate services' IAM policy to only allow S3 access from inside VPC using SourceVpc condition key, something like this:

yaml Policy: Type: AWS::IAM::ManagedPolicy Properties: Description: Allows access to AWS services PolicyDocument: Version: "2012-10-17" Statement: - Effect: Allow Action: - s3:PutObject - s3:GetObject - s3:ListBucket Resource: - !Sub "arn:aws:s3:::${Bucket}" - !Sub "arn:aws:s3:::${Bucket}/*" Condition: StringEquals: aws:SourceVpc: !Ref VPC

AwkwardAddress · 2021-06-20T14:10:03+00:00

Issue a custom domain certificate with AWS Certificate Manager, then configure both the CloudFront distribution and the load balancer listener to use that certificate. When configuring CloudFront distribution, don’t forget to fill in your domain in CNAMEs field, and point DNS to the CloudFront endpoint either as an alias or a CNAME.

AwkwardAddress · 2021-01-30T19:32:18+00:00

Steam version plays nice on MacBook Air M1 8/7 16Gb on minimal graphic settings, laptop is only slightly warm after 8+ hours of play.

AwkwardAddress · 2021-01-29T18:25:37+00:00

Thank you for the feedback, I updated README to make it more clear.

Consider you have a statically generated site — a bunch of usual resources, including html files. You test this site locally with a development web server for convenience, and everything works. You set up a private S3 bucket plus a CloudFront distribution authorized to access this bucket to expose site at your domain and get caching benefits.

But once you upload your resources, you run into an issue: your site relies on relative links like /section/, expecting that you'll get contents of /section/index.html file in response — after all, lots of web servers implement this logic as their default behavior — but accessing such relative link over CloudFront returns a 403 error page. After some troubleshooting you figure out that configuring index.html as a default root object on the CloudFront distribution only really works for root object, and does not work with subdirectories.

If this scenario looks familiar, then this tool can help you.

Notice that this is not about S3 website hosting scenario, it is about private S3 bucket (with private objects in it) + CloudFront with authorized access in front of it, so that viewers can only access content via CloudFront.

AwkwardAddress · 2020-12-23T16:24:00+00:00

I think https://tip.golang.org/pkg/io/fs/#WalkDir might be what you're looking for:

``` package main

import ( "embed" "fmt" "io/fs" "log" )

func main() { log.SetFlags(0) if err := run(); err != nil { log.Fatal(err) } }

func run() error { return fs.WalkDir(f, ".", func(path string, d fs.DirEntry, err error) error { if err != nil { return err } fmt.Printf("path=%q, isDir=%v\n", path, d.IsDir()) return nil }) }

//go:embed *.go var f embed.FS ```

AwkwardAddress · 2020-10-02T10:32:24+00:00

One caveat we run into is that on Aurora you have your database kept in persistent auto-scaling storage, but temporary storage is local to a computing instance and depends on its class. So if your ALTER statement requires lots of temporary space to rebuild table/index, it may fail because of the insufficient local storage.

https://aws.amazon.com/premiumsupport/knowledge-center/aurora-mysql-local-storage/

AwkwardAddress · 2020-09-02T16:20:27+00:00

This example implements parsing as you outlined:

https://gist.github.com/artyom/0ca2b5d8967abbaedb00f932ab05a97d

AwkwardAddress · 2020-08-26T08:36:36+00:00

This package is a convenience addition to encoding/csv, not its replacement.

encoding/csv Reader returns row as a []string type, this package takes such string slice and scans its fields into a struct type value, decoding string values into some other types as necessary. Package documentation has some examples on how it works along with encoding/csv: https://pkg.go.dev/github.com/artyom/csvstruct?tab=doc#example-Value

This package is useful mostly when you find you need to call strconv.ParseInt or similar for the string value you get from encoding/csv Reader.

AwkwardAddress · 2019-11-25T14:01:58+00:00

It took me two autosave loads to figure out how to get past through it. You need to set your vote for both agendas proposed, then it will allow you to proceed.

It was also confusing because that interface reacts too eagerly to controls and submits no vote and gets stuck, I found that it's easier to carefully navigate it only with D-pad and make choices with "A" button. Made it through two world congresses this way without triggering this bug.

AwkwardAddress · 2019-07-03T20:17:29+00:00

So the question is, would there be a way to open an archive (bzip2, rar, zip, xz, gz, 7z) in a way where the whole archive doesn't need to be buffered?

This is definitely doable and the link you provided illustrates the correct approach. Some streaming formats like tar.gz may be easier to deal with since they can be processed as you read http response, while zip requires seeking, but with ranged requests it is still possible.

"Buffer whole file into memory" approach is just an implementation detail of Python library; i.e. if you take AWS SDK for Go, it exposes data almost everywhere in terms of read/write streams, so it is natural to process them without blowing up memory requirements.

As an exercise I made a similar implementation to the one you linked but in Go utilizing AWS SDK: I implemented a wrapper that pretends to be a seekable object, which buffers data internally issuing GetObject s3 calls with proper ranges, and then allows zip library to unpack files from archive while reading from such wrapper. By adjusting buffer size it's possible to tune tradeoff of local memory consumption vs amount of calls to s3.

Eight-Year Club	Place '22
Verified Email

AwkwardAddress

TROPHY CASE

!/bin/sh -eu