Jump: Jump Helps You Navigate Faster By Learning Your Habits

Jump integrates with your shell and learns about your navigational habits by keeping track of the directories you visit. It gives you the most visited directory for the shortest search term you type.

Installation

Jump comes in packages for the following platforms.

Platform	Command
macOS	brew install jump or port install jump
Linux	sudo snap install jump
Nix	nix-env -iA nixpkgs.jump
Go	go install github.com/gsamokovarov/jump@latest

Linux distribution specific packages

Distribution	Command
Void	xbps-install -S jump
Ubuntu	wget https://github.com/gsamokovarov/jump/releases/download/v0.40.0/jump_0.40.0_amd64.deb && sudo dpkg -i jump_0.40.0_amd64.deb
Debian	wget https://github.com/gsamokovarov/jump/releases/download/v0.40.0/jump_0.40.0_amd64.deb && sudo dpkg -i jump_0.40.0_amd64.deb
Fedora	wget https://github.com/gsamokovarov/jump/releases/download/v0.40.0/jump-0.40.0-1.x86_64.rpm && sudo rpm -i jump-0.40.0-1.x86_64.rpm

Integration

You are using Jump through its shell helper function, j. To get it, you have to integrate Jump with your shell.

bash / zsh

Add the he line below in ~/.bashrc, ~/bash_profile or ~/.zshrc:

eval "$(jump shell)"

fish

Add the line below in ~/.config/fish/config.fish:

jump shell fish | source

PowerShell

Add the line below needs to your profile, located by typing $PROFILE in Powershell:

Invoke-Expression (&jump shell pwsh | Out-String)

Once integrated, jump will automatically monitor directory changes and start building an internal database.

But j is not my favourite letter!

This is fine, you can bind jump to z with the following integration command:

eval "$(jump shell --bind=z)"

Typing z dir would just work! This is only an example, you can bind it to anything. If you are one of those persons that likes to type a lot with their fingers, you can do:

eval "$(jump shell --bind=goto)"

Voila! goto dir becomes a thing. The possibilities are endless!

Usage

Once integrated, jump introduces the j helper. It accepts only search terms and as a design goal there are no arguments to j. Whatever you give it, it's treated as search term.

Jump uses fuzzy matching to find the desired directory to jump to. This means that your search terms are patterns that match the desired directory approximately rather than exactly. Typing 2 to 5 consecutive characters of the directory name is all that jump needs to find it.

Regular jump

The default search behavior of jump is to fuzzy match the directory name of a score. The match is case insensitive.

If you visit the directory /Users/genadi/Development/rails/web-console often, you can jump to it by:

$ j wc      # or...
$ j webc    # or...
$ j console # or...
$ j b-c     # or...

Using jump is all about saving key strokes. However, if you made the effort to type a directory base name exactly, jump will try to find the exact match, rather than fuzzy search.

$ j web-console
$ pwd
/Users/genadi/Development/rails/web-console

Deep jump

Given the following directories:

/Users/genadi/Development/society/website
/Users/genadi/Development/chaos/website

Typing j site matches only the base names of the directories. The base name of /Users/genadi/Development/society/website is website, the same as the other absolute path above. The jump above will land on the most scrored path, which is the society one, however what if we wanted to land on the chaos website?

$ j ch site
$ pwd
/Users/genadi/Development/chaos/website

This instructs jump to look for a site match inside that is preceded by a ch match in the parent directory. The search is normalized only on the last two parts of the target paths. This will ensure a better match, because of the shorter path to fuzzy match on.

There are no depth limitations though and a jump to /Users/genadi/Development/society/website can look like:

$ j dev soc web
$ pwd
/Users/genadi/Development/society/website

In fact, every space passed to j is converted to an OS separator. The last search term can be expressed as:

$ j dev/soc/web
$ pwd
/Users/genadi/Development/society/website

Reverse jump

Bad jumps happen. Sometimes we're looking for a directory that doesn't have the best score at the moment. Let's work with the following following jump database:

/Users/genadi/Development/society/website
/Users/genadi/Development/chaos/website
/Users/genadi/Development/hack/website

Typing j web would lead to:

$ j web
$ pwd
/Users/genadi/Development/society/website

If we didn't expect this result, instead of another search term, typing j without any arguments will instruct jump to go the second best match.

$ j
$ pwd
/Users/genadi/Development/chaos/website

Case sensitive jump

To trigger a case-sensitive search, use a term that has a capital letter.

$ j Dev
$ pwd
/Users/genadi/Development

The jump will resolve to /Users/genadi/Development even if there is /Users/genadi/Development/dev-tools that scores better.

Is it like autojump or z?

Yes, it is! You can import your datafile from autojump or z with:

$ jump import

This will try z first then autojump, so you can even combine all the entries from both tools.

The command is safe to run on pre-existing jump database, because if an entry exist in jump already, it won't be imported and it's score will remain unchanged. You can be explicit and choose to import autojump or z with:

$ jump import autojump
$ jump import z

If you want to know more about the difference between Jump, z, and autojump, check-out this Twitter conversation.

Thanks! 🙌

Thank you for stopping by and showing your interest in Jump!

Author: Gsamokovarov
Source Code: https://github.com/gsamokovarov/jump 
License: MIT license

#go #golang #bash 

What is GEEK

Buddha Community

Top 9+ Common CSS Mistakes To Avoid

In this tutorial, we'll summarise what the top 9+ CSS mistakes are and how to avoid them.

Top 9+ Common CSS Mistakes To Avoid

It’s easy to get tripped up with CSS. Here are some common CSS mistakes we all make.

1. Not Using a Proper CSS Reset

Web browsers are our fickle friends. Their inconsistencies can make any developer want to tear their hair out. But at the end of the day, they’re what will present your website, so you better do what you have to do to please them.

One of the sillier things browsers do is provide default styling for HTML elements. I suppose you can’t really blame them: what if a “webmaster” chose not to style their page? There has to be a fallback mechanism for people who choose not to use CSS.

In any case, there’s rarely a case of two browsers providing identical default styling, so the only real way to make sure your styles are effective is to use a CSS reset. What a CSS reset entails is resetting (or, rather, setting) all the styles of all the HTML elements to a predictable baseline value. The beauty of this is that once you include a CSS reset effectively, you can style all the elements on your page as if they were all the same to start with.

It’s a blank slate, really. There are many CSS reset codebases on the web that you can incorporate into your work. I personally use a modified version of the popular Eric Meyer reset and Six Revisions uses a modified version of YUI Reset CSS.

You can also build your own reset if you think it would work better. What many of us do is utilizing a simple universal selector margin/padding reset.

* { margin:0; padding:0; } 

Though this works, it’s not a full reset.

You also need to reset, for example, borders, underlines, and colors of elements like list items, links, and tables so that you don’t run into unexpected inconsistencies between web browsers. Learn more about resetting your styles via this guide: Resetting Your Styles with CSS Reset.

2. Over-Qualifying Selectors

Being overly specific when selecting elements to style is not good practice. The following selector is a perfect example of what I’m talking about:

ul#navigation li a { ... } 

Typically the structure of a primary navigation list is a <ul> (usually with an ID like #nav or #navigation) then a few list items (<li>) inside of it, each with its own <a> tag inside it that links to other pages.

This HTML structure is perfectly correct, but the CSS selector is really what I’m worried about. First things first: There’s no reason for the ul before #navigation as an ID is already the most specific selector. Also, you don’t have to put li in the selector syntax because all the a elements inside the navigation are inside list items, so there’s no reason for that bit of specificity.

Thus, you can condense that selector as:

#navigation a { ... } 

This is an overly simplistic example because you might have nested list items that you want to style differently (i.e. #navigation li a is different from #navigation li ul li a); but if you don’t, then there’s no need for the excessive specificity.

I also want to talk about the need for an ID in this situation. Let’s assume for a minute that this navigation list is inside a header div (#header). Let us also assume that you will have no other unordered list in the header besides the navigation list.

If that is the case, we can even remove the ID from the unordered list in our HTML markup, and then we can select it in CSS as such:

#header ul a { ... } 

Here’s what I want you to take away from this example: Always write your CSS selectors with the very minimum level of specificity necessary for it to work. Including all that extra fluff may make it look more safe and precise, but when it comes to CSS selectors, there are only two levels of specificity: specific, and not specific enough.

3. Not Using Shorthand Properties

Take a look at the following property list:

#selector { margin-top: 50px; margin-right: 0; margin-bottom: 50px; margin-left 0; }

What is wrong with this picture? I hope that alarm bells are ringing in your head as you notice how much we’re repeating ourselves. Fortunately, there is a solution, and it’s using CSS shorthand properties.

The following has the same effect as the above style declaration, but we’ve reduced our code by three lines.

#selector { margin: 50px 0; }

Check out this list of properties that deals with font styles:

font-family: Helvetica; font-size: 14px; font-weight: bold; line-height: 1.5;

We can condense all that into one line:

font: bold 14px/1.5 Helvetica; 

We can also do this for background properties. The following:

background-image: url(background.png); background-repeat: repeat-y; background-position: center top;

Can be written in shorthand CSS as such:

background: url(background.png) repeat-y center top; 

4. Using 0px instead of 0

Say you want to add a 20px margin to the bottom of an element. You might use something like this:

#selector { margin: 20px 0px 20px 0px; } 

Don’t. This is excessive.

There’s no need to include the px after 0. While this may seem like I’m nitpicking and that it may not seem like much, when you’re working with a huge file, removing all those superfluous px can reduce the size of your file (which is never a bad thing).

5. Using Color Names Instead of Hexadecimal

Declaring red for color values is the lazy man’s #FF0000. By saying:

color: red;

You’re essentially saying that the browser should display what it thinks red is. If you’ve learned anything from making stuff function correctly in all browsers — and the hours of frustration you’ve accumulated because of a stupid list-bullet misalignment that can only be seen in IE7 — it’s that you should never let the browser decide how to display your web pages.

Instead, you should go to the effort to find the actual hex value for the color you’re trying to use. That way, you can make sure it’s the same color displayed across all browsers. You can use a color cheatsheet that provides a preview and the hex value of a color.

This may seem trivial, but when it comes to CSS, it’s the tiny things that often lead to the big gotchas.

6. Redundant Selectors

My process for writing styles is to start with all the typography, and then work on the structure, and finally on styling all the colors and backgrounds. That’s what works for me. Since I don’t focus on just one element at a time, I commonly find myself accidentally typing out a redundant style declaration.

I always do a final check after I’m done so that I can make sure that I haven’t repeated any selectors; and if I have, I’ll merge them. This sort of mistake is fine to make while you’re developing, but just try to make sure they don’t make it into production.

7. Redundant Properties

Similar to the one above, I often find myself having to apply the same properties to multiple selectors. This could be styling an <h5> in the header to look exactly like the <h6> in the footer, making the <pre>‘s and <blockquote>‘s the same size, or any number of things in between. In the final review of my CSS, I will look to make sure that I haven’t repeated too many properties.

For example, if I see two selectors doing the same thing, such as this:

#selector-1 { font-style: italic; color: #e7e7e7; margin: 5px; padding: 20px } .selector-2 { font-style: italic; color: #e7e7e7; margin: 5px; padding: 20px }

I will combine them, with the selectors separated by a comma (,):

#selector-1, .selector-2 { font-style: italic; color: #e7e7e7; margin: 5px; padding: 20px }

I hope you’re seeing the trend here: Try to be as terse and as efficient as possible. It pays dividends in maintenance time and page-load speed.

8. Not Providing Fallback Fonts

In a perfect world, every computer would always have every font you would ever want to use installed. Unfortunately, we don’t live in a perfect world. @font-face aside, web designers are pretty much limited to the few so called web-safe fonts (e.g.

Arial, Georgia, serif, etc.). There is a plus side, though. You can still use fonts like Helvetica that aren’t necessarily installed on every computer.

The secret lies in font stacks. Font stacks are a way for developers to provide fallback fonts for the browser to display if the user doesn’t have the preferred font installed. For example:

#selector { font-family: Helvetica; }

Can be expanded with fallback fonts as such:

#selector { font-family: Helvetica, Arial, sans-serif; }

Now, if the user doesn’t have Helvetica, they can see your site in Arial, and if that doesn’t work, it’ll just default to any sans-serif font installed.

By defining fallback fonts, you gain more control as to how your web pages are rendered.

9. Unnecessary Whitespace

When it comes to trying to reduce your CSS file sizes for performance, every space counts. When you’re developing, it’s OK to format your code in the way that you’re comfortable with. However, there is absolutely no reason not to take out excess characters (a process known as minification) when you actually push your project onto the web where the size of your files really counts.

Too many developers simply don’t minify their files before launching their websites, and I think that’s a huge mistake. Although it may not feel like it makes much of a difference, when you have huge CSS files

10. Not Organizing Your CSS in a Logical Way

When you’re writing CSS, do yourself a favor and organize your code. Through comments, you can insure that the next time you come to make a change to a file you’ll still be able to navigate it. 

I personally like to organize my styles by how the HTML that I’m styling is structured. This means that I have comments that distinguish the header, body, sidebar, and footer. A common CSS-authoring mistake I see is people just writing up their styles as soon as they think of them.

The next time you try to change something and can’t find the style declaration, you’ll be silently cursing yourself for not organizing your CSS well enough.

11. Using Only One Stylesheet for Everything

This one’s subjective, so bear with me while I give you my perspective. I am of the belief, as are others, that it is better to split stylesheets into a few different ones for big sites for easier maintenance and for better modularity. Maybe I’ll have one for a CSS reset, one for IE-specific fixes, and so on.

By organizing CSS into disparate stylesheets, I’ll know immediately where to find a style I want to change. You can do this by importing all the stylesheets into a stylesheet like so:

@import url("reset.css"); @import url("ie.css"); @import url("typography.css"); @import url("layout.css"); 

Let me stress, however, that this is what works for me and many other developers. You may prefer to squeeze them all in one file, and that’s okay; there’s nothing wrong with that.

But if you’re having a hard time maintaining a single file, try splitting your CSS up.

12. Not Providing a Print Stylesheet

In order to style your site on pages that will be printed, all you have to do is utilize and include a print stylesheet. It’s as easy as:

<link rel="stylesheet" href="print.css" media="print" /> 

Using a stylesheet for print allows you to hide elements you don’t want printed (such as your navigation menu), reset the background color to white, provide alternative typography for paragraphs so that it’s better suited on a piece of paper, and so forth. The important thing is that you think about how your page will look when printed.

Too many people just don’t think about it, so their sites will simply print the same way you see them on the screen.

---

I Made These 2 BEGINNER CSS Mistakes

No matter how long you've been writing code, it's always a good time to revisit the basics. While working on a project the other day, I made 2 beginner mistakes with the CSS I was writing. I misunderstood both CSS specificity and how transform:scale affects the DOM!

Stack Overflow about transform:scale - https://stackoverflow.com/questions/32835144/css-transform-scale-does-not-change-dom-size 
CSS Specificity - https://www.w3schools.com/css/css_specificity.asp 

#css 

Google Reveals "What is being Transferred” in Transfer Learning

Recently, researchers from Google proposed the solution of a very fundamental question in the machine learning community — What is being transferred in Transfer Learning? They explained various tools and analyses to address the fundamental question.

The ability to transfer the domain knowledge of one machine in which it is trained on to another where the data is usually scarce is one of the desired capabilities for machines. Researchers around the globe have been using transfer learning in various deep learning applications, including object detection, image classification, medical imaging tasks, among others.

#developers corner #learn transfer learning #machine learning #transfer learning #transfer learning methods #transfer learning resources

Deep Learning for Inertial Navigation

Introduction

Many vision aiding navigation approaches were presented in the last decade as there is a wide range of applications these days (Huang, 2019). Saying that, the classical field of inertial navigation with low-cost inertial sensors as the only source of information is starting getting attention with novel deep learning methods that are involved in it. The main problem of inertial navigation is the drift, which is a key source for errors. More problem involves wrong initialization, wrong modeling of the sensors, and approximation errors.

In this post, we review the integration of deep learning in classical Inertial Navigation System (INS) with Inertial Measurement Units (IMU’s) only to solve part of the problem mentioned above. First, we present some cutting edge architectures for improved speed estimation, noise reduction, zero-velocity detection, and attitude & position prediction. Secondly, the KITTI and OxIOD dataset are discussed. Lastly, schemes of pedestrian inertial navigation with deep learning are presented.

Cutting edge deep learning-based Solutions

One of the main problems in the navigation field is speed estimation. As the estimation becomes accurate it affect also on the position solution. In a work published in 2018 by Cortes et al, a deep learning-based speed estimation approach was suggested. The main idea was to add a speed constrain to the classical Inertial Navigation System (INS). They estimated the speed from the IMU only by using a CNN and then constrained the INS solution by this prediction. Formulating this estimation as a regression deep learning task, where the inputs are the six-channel of the IMU over a few seconds, and the output is the speed, leads to improved trajectory tracking as also motion mode classification.

Cortes et al, 2018

The next work I want to present regarding noise reduction. As many low-cost sensors suffer from the high magnitude of noise and characterized by a noise profile, where the noise changes with time, there is a need to filter it. But as these noise profiles are difficult to estimate, using a deep learning-based approach seems to solve this issue. Chen et al (2018) presented a novel deep learning approach to deal with many error sources in the sensor signals. By doing that, the sensors’ signals can be corrected and only then to be used in the navigation scheme. They reported 80% accuracy on the correct identification of the IMU signals. CNN was also used in this work, where it includes 5 convolutional layers and one fully-connected layer.

#tracking #ai #navigation #machine-learning #deep-learning #deep learning

5 Latest Technology Trends of Machine Learning for 2021

Check out the 5 latest technologies of machine learning trends to boost business growth in 2021 by considering the best version of digital development tools. It is the right time to accelerate user experience by bringing advancement in their lifestyle.

#machinelearningapps #machinelearningdevelopers #machinelearningexpert #machinelearningexperts #expertmachinelearningservices #topmachinelearningcompanies #machinelearningdevelopmentcompany

Visit Blog- https://www.xplace.com/article/8743

#machine learning companies #top machine learning companies #machine learning development company #expert machine learning services #machine learning experts #machine learning expert

Intro to Reinforcement Learning: Temporal Difference Learning, SARSA Vs. Q-learning

Reinforcement learning (RL) is surely a rising field, with the huge influence from the performance of AlphaZero (the best chess engine as of now). RL is a subfield of machine learning that teaches agents to perform in an environment to maximize rewards overtime.

Among RL’s model-free methods is temporal difference (TD) learning, with SARSA and Q-learning (QL) being two of the most used algorithms. I chose to explore SARSA and QL to highlight a subtle difference between on-policy learning and off-learning, which we will discuss later in the post.

This post assumes you have basic knowledge of the agent, environment, action, and rewards within RL’s scope. A brief introduction can be found here.

The outline of this post include:

• Temporal difference learning (TD learning)
• Parameters
• QL & SARSA
• Comparison
• Implementation
• Conclusion

We will compare these two algorithms via the CartPole game implementation. This post’s code can be found here :QL code ,SARSA code , and the fully functioning code . (the fully-functioning code has both algorithms implemented and trained on cart pole game)

The TD learning will be a bit mathematical, but feel free to skim through and jump directly to QL and SARSA.

#reinforcement-learning #artificial-intelligence #machine-learning #deep-learning #learning