Unfortunately Firefox is getting worse every day, specially after the introduction of the horrible v89 interface. Having to resort to Chrome again demands some precautions.
Latest Chrome 94 introduced an idle detection feature, which is a privacy nightmare. Fortunately, we still can disable it here:
chrome://settings/content/idleDetection
And don’t forget to also disable the privacy sandbox and FLoC features:
chrome://settings/privacySandbox
I really wish I could go back to ol’ good Firefox.
Just for the record, these are the settings I’m always using with Visual Studio 2019, when creating a new, empty C++ project:
$(SolutionDir)$(Platform)_$(Configuration)\$(Platform)_$(Configuration)\ISO C++20 Standard (/std:c++20)None (Release)Yes (/WX) (Release)Yes (/MP)Multi-threaded (/MT) (Release)No (Release)Windows (/SUBSYSTEM:WINDOWS)As of April 2024, the settings above also apply to Visual Studio 2022.
This should be something rather rare, but for some reason I keep needing to do it very often: I want to add a new, unrelated branch into an existing repository, and this branch comes from another repository.
While needing to do this yet again today, I found a rather elegant solution here:
git switch --orphan NEW_BRANCH git pull FORK_URL FORK_BRANCH
It works remarkably well and clean. Props to the guy who shared this.
Today I had to deep clone objects in Java. What a nightmare.
First, the Cloneable interface is horribly broken, and writing such a simply code becomes a laborious task. Second, if the object has a List as a field, you must manually clone the elements into a new List.
The code goes as it follows:
public class Foo implements Cloneable {
private String name;
private List words;
@Override
public Object clone() {
try {
Foo cloned = (Foo) super.clone();
cloned.words = Auxiliar.cloneList(words);
return cloned;
} catch (CloneNotSupportedException e) {
System.out.println("Never happens!");
return null;
}
}
// Getters and setters omitted.
}
Notice the Another.cloneList() call? This is where we manually clone all the List elements, by calling clone() in each one. This is the solution I found for a generic method:
public class Auxiliar {
@SuppressWarnings("unchecked")
public static <T extends Cloneable> List<T> cloneList(List<T> list) {
try {
List<T> newList = new ArrayList<>(list.size());
for (T item : list) {
newList.add((T) item.getClass().getMethod("clone").invoke(item));
}
return newList;
} catch (IllegalAccessException | IllegalArgumentException
| InvocationTargetException | NoSuchMethodException | SecurityException e) {
System.out.println("Never happens!");
return null;
}
}
}
No idea why Cloneable was not deprecated and replaced by something minimally decent yet.
Apparently with my Gibson Les Paul craze back again, I’ve been dabbling into the specs of the High Performance series. The specs list the fretwire as “Low”, without any further info on the actual dimensions. Also, other models are listed as having “Medium Jumbo” fretwire. What do they mean?
Fortunately Gibson Customer Service kindly answered my emails, and these are the measures:
| Fretwire | Height | Width |
|---|---|---|
| Medium Jumbo | .055" | .090" |
| Low | .045" | .086" |
This information, paired with this fretwire chart and our JP chart, gives us a good comparison with commonly known fret sizes:
| Fretwire | Height | Width | |
|---|---|---|---|
| Dunlop | 6000 | .058" | .118" |
| 6100 (Ibanez JPM) | .055" | .110" | |
| 6105 (Ibanez JEM) | .055" | .090" | |
| 6140 (Ibanez Universe) | .039" | .106" | |
| EBMM | medium jumbo (Majesty) | .051" | .108" |
| high wide (JP6) | .047" | .104" | |
| Suhr | jumbo | .057" | .110" |
| medium | .055" | .090" | |
| heavy | .051" | .108" | |
I just can’t understand, however, why would they use vintage frets in such a modern guitar.
In whathever programming language, it’s rather common to have a function which accepts an array of strings. Specifically in Rust, there is the notion of slice, which can be used as a reference to a Vec. And also there is the notion of &str, which can be used as a reference to String. Putting both concepts together as an argument is not trivial, though.
Turns out I found a way to make it work by using the AsRef trait – as many things in Rust, traits lead the way. By using generics, it becomes possible:
fn foo<S: AsRef<str>>(names: &[S]) {
for name in names.iter().map(|s| s.as_ref()) {
println!("{}", name);
}
}
Or alternatively using the impl keyword for the trait bound:
fn foo(names: &[impl AsRef<str>]) {
for name in names.iter().map(|s| s.as_ref()) {
println!("{}", name);
}
}
The function above accepts both Vec and slice of String or &str. But notice how, in order to retrieve the string itself, the as_ref() method must be called.
Hello, dear reader.
I started this blog exactly 10 years ago, in a Saturday morning, without having much idea about what I’d write here. I just wanted a safe place to vent.
Now, after 10 years, there’s quite an interesting content written down. In many ways, it’s a window to see my own maturing on various topics. Things that matter – or mattered at the time – to me, and nobody else. Well, actually some posts did generate outsiders’ interest but that’s not the point: this is a personal blog in the most actual sense.
But the thing is that it feels like it was yesterday. 10 years went by.
Just out of curiosity, I wrote a Rust macro similar to Visual Basic’s IIf function:
macro_rules! iif {
($cond:expr, $iftrue:expr, $iffalse:expr) => {
if $cond { $iftrue } else { $iffalse }
};
}
Usage:
let n = iif!(1 == 1, "yes", "no");
Close to the ternary operator, which I’m sorely missing in these Rust days.
In searching for a fix to the Firefox 89 Proton layout catastrophe, I found a very neat site which tries to summarize all the fixes that can be made in “userChrome.css” file, which can be found in about:profiles internal URL, and enabled with toolkit.legacyUserProfileCustomizations.stylesheets in about:config.
Unfortunately, it’s not possible to restore the menu icons, as of yet, but it’s still a relief from that disaster.
This is my hack for Linux:
/*** Tighten up drop-down/context/popup menu spacing ***/
menupopup > menuitem, menupopup > menu {
padding-block: 4px !important;
}
:root {
--arrowpanel-menuitem-padding: 4px 8px !important;
}
/*** Proton Tabs Tweaks ***/
/* Adjust tab corner shape, optionally remove space below tabs */
#tabbrowser-tabs {
--user-tab-rounding: 0px;
}
@media (-moz-proton) {
.tab-background {
border-radius: var(--user-tab-rounding) var(--user-tab-rounding) 0px 0px !important;
margin-block: 1px 0 !important;
}
#scrollbutton-up, #scrollbutton-down { /* 6/10/2021 */
border-top-width: 1px !important;
border-bottom-width: 0 !important;
}
/* Container color bar visibility */
.tabbrowser-tab[usercontextid] > .tab-stack > .tab-background > .tab-context-line {
margin: 0px max(calc(var(--user-tab-rounding) - 3px), 0px) !important;
}
}
/* Inactive tabs: Separator line style */
@media (-moz-proton) {
.tabbrowser-tab:not([selected=true]):not([multiselected=true]):not([beforeselected-visible="true"]) .tab-background {
border-right: 1px solid rgba(0, 0, 0, .20) !important;
}
/* For dark backgrounds */
[brighttext="true"] .tabbrowser-tab:not([selected=true]):not([multiselected=true]):not([beforeselected-visible="true"]) .tab-background {
border-right: 1px solid var(--lwt-selected-tab-background-color, rgba(255, 255, 255, .20)) !important;
}
.tabbrowser-tab:not([selected=true]):not([multiselected=true]) .tab-background {
border-radius: 0 !important;
}
/* Remove padding between tabs */
.tabbrowser-tab {
padding-left: 0 !important;
padding-right: 0 !important;
}
}
One of my all-time favorite features of Go is the defer mechanism. It’s so incredibly simple, and so incredibly ingenious and useful. The fact the deferred statements are called during a panic unwind makes me want to use it in other languages, like Rust.
As for Rust, I’m aware of the scopeguard crate, but it seems to be an overkill to such a simple concept. Plus, it does some fishy workaround to make the FnOnce.
So I decided to write my own Rust version of the defer mechanism, which turns out to be a macro that hides the creation of an object. This object holds a FnOnce which runs when at the end of the scope via Drop trait:
/// Internal struct used by the `defer!` macro.
pub struct Defer<F: FnOnce()> {
func: Option<F>,
}
impl<F: FnOnce()> Defer<F> {
pub fn new(func: F) -> Self {
Self { func: Some(func) }
}
}
impl<F: FnOnce()> Drop for Defer<F> {
fn drop(&mut self) {
self.func.take().map(|f| f());
}
}
/// Defers the execution of a block until the surrounding scope ends.
macro_rules! defer {
( $($tt:tt)* ) => {
let _deferred = crate::defer::Defer::new(|| { $($tt)* });
};
}
Usage is straightforward:
#[macro_use] mod defer; // considering defer.rs at crate's root
fn main() {
defer! { println!("hi"); }
}
Edit: I published the code above as a crate: defer-lite.
One thing I always missed in Go was sum types. I’ve seen some discussion before. Although Go doesn’t have this as an explicit, native feature, I found a pattern that suits my needs by defining types and interfaces.
In the example below, I simulate a function that would load application resources, which can be extracted by ID, position or a string identifier. First, we define the interface and the subtypes:
type (
// Variant type for: ResId, ResPos, ResStr.
Res interface{ implRes() }
ResId uint32
ResPos uint32
ResStr string
)
func (ResId) implRes() {}
func (ResPos) implRes() {}
func (ResStr) implRes() {}
The isRes() function acts like a “tag” for each subtype.
Now, a function that receives the variant type:
func LoadResource(variant Res) {
switch v := variant.(type) {
case ResId:
println("ID", uint32(v))
case ResPos:
println("Position", uint32(v))
case ResStr:
println("String", string(v))
default:
panic("Res does not accept a nil value.")
}
}
Usage is now trivial:
LoadResource(ResId(2001))
LoadResource(ResPos(4))
LoadResource(ResStr("MY_ICON"))
It’s clean and it works remarkably well. I applied this technique in my Windigo library.
I always used FileTypesMan to register the Windows file associations. But after Windows 7 or so, some associations simply refused to work, leaving them wrong. In Windows 10, this problem worsened.
Today, after digging the associations created by Reaper, I figured out one of the correct ways to register a file association – there are other exotic ways too, which I couldn’t figure out yet.
These are the Windows Registry entries that must be created:
HKEY_CLASSES_ROOT\.fuu\
(Default) REG_SZ Fuu.File
Content Type REG_SZ text/plain
PerceivedType REG_SZ text
HKEY_CLASSES_ROOT\Fuu.Type\
(Default) REG_SZ A fuu file.
DefaultIcon\
(Default) REG_SZ C:\Temp\fuu.exe,0
shell\
(Default) REG_SZ open64
open64\
(Default) REG_SZ Open file in Fuu
command\
(Default) REG_SZ "C:\Temp\fuu.exe" "%1"
And these entries map correctly in FileTypesMan, which can be used to further changes.
Note that Content Type and PerceivedType will automatically create “Open” entries mapped to default applications, so you probably won’t want those. In its simplest form, this will work:
HKEY_CLASSES_ROOT\.fuu\
(Default) REG_SZ Fuu.File
HKEY_CLASSES_ROOT\Fuu.Type\
(Default) REG_SZ A fuu file.
DefaultIcon\
(Default) REG_SZ C:\Temp\fuu.exe,0
shell\
open\
command\
(Default) REG_SZ "C:\Temp\fuu.exe" "%1"