Free AI web copilot to create summaries, insights and extended knowledge, download it at here

4324

Abstract

span> (c *calculator) Calculate(num... int) { ans := 0 for _, n := range num { ans += n } fmt.Println(ans) }

var Calculator calculator</pre></div>We exposed a struct which implements the method Calculate. This is required for the discovery and registration of the plugin. Now to compile this and make it a shared-object we need to build the library as a plugin.<div id="b6b4"><pre>go build -o -buildmode=plugin .</pre></div>After this, we will have a shared object file(in our case “add.so”) which we can dynamically load at runtime in our main application.<figure id="5129"><img src="https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*HEBnzWVkvUP0JjhOsfOH7Q.png"><figcaption>updated file structure of the library</figcaption></figure>Now to dynamically load the library into our main application at run time we need use the plugin system of Golang.<div id="0960"><pre>import ( "fmt" "os" "plugin" )

type Calculator interface { Calculate(num... int) }

func main() { calculatorPlugin, err := plugin.Open("/abs/path/to/shared/object/file") if err != nil { fmt.Println("error while opening shared object file") os.Exit(1) }

symCalculator, err := calculatorPlugin.Lookup("Calculator") if err != nil { fmt.Println("error while lookup") os.Exit(1) }

var calculator Calculator calculator, ok := symCalculator.(Calculator) if !ok { fmt.Println("unexpected type from module symbol") os.Exit(1) }

calculator.Calculate(3,4) }</pre></div>In this case if we are making any changes to library, we don’t need to re-compile our main application. We only need to recompile the library’s shared object and rerun our main application.Due to the different characteristics, the advantages and disadvantages of static and dynamic libraries are also obvious; binaries that rely only on static libraries and are generated by static linking can be executed independently because they contain all the dependencies, but the compilation result is also larger. Dynamic libraries can be shared among multiple executables, which can reduce the memory footprint, and their linking process is often triggered during loading or running, so they can contain some modules that can be hot-plugged and reduce the memory footprint. Compiling binaries using static linking has very obvious deployment advantages, and the final compiled product will run directly on most machines. The deployment benefits of static linking are far more important than the lower memory footprint, that’s why Golang uses static linking as the default linking method.<h1 id="d290">Issues with Dynamic-linking (shared library plugins) in Go</h1>Plugins using shared libraries and the plugin package work well for Golang, as the previous section demonstrates. However, this approach also has some serious downsides. The most important downside is that Golang is very picky about keeping the main application and the shared libraries it loads compatible.As an experiment, try using different versions of a common d

Options

ependency in the plugin application and the main application, rebuild the main application and run it. Most likely you’ll get this error:<div id="443c"><pre>"plugin was built with a different version of package XXX"</pre></div><figure id="d928"><img src="https://cdn-images-1.readmedium.com/v2/resize:fit:800/0*ow5zqQqWHmQoZqaC.gif"><figcaption></figcaption></figure>The reason for this is that Golang wants all the versions of all packages in the main application and plugins to match exactly. It’s clear what motivates this: safety.Consider C and C++ as counter-examples. In these languages, an application can load a shared library with dlopen and subsequently use dlsym to obtain symbols from it. dlsym is extremely weakly typed; it takes a symbol name and returns a void*. It’s up to the user to cast this to a concrete function type. If the function type changes because of a version update, the result can very likely be some sort of segmentation fault or even memory corruption.Since Golang relies on shared libraries from plugins, it has the same inherent safety issues. It tries to protect programmers from shooting themselves in the foot by ensuring that the application has been built with the same versions of packages as all its plugins. This helps avoid mismatch. In addition, the version of the Golang compiler used to build the application and plugins must match exactly.However, this protection comes with downsides — making developing plugins somewhat cumbersome. Having to rebuild all plugins whenever any common packages change — even in ways that don’t affect the plugin interface — is a heavy burden. Especially, considering that by their very nature plugins are typically developed separately from the main application; they may live in separate repositories, have separate release cadences etc.<h1 id="bfc1">Alternative approaches to shared library plugins in Golang</h1>Given that the plugin package was only added to Go in <a href="https://golang.org/doc/go1.8">version 1.8</a> and the limitation described previously, it’s not surprising that the Go ecosystem saw the emergence of alternative plugin approaches.One of the innovative approaches involves plugins via RPC. In this method instead of loading the plugins into the host process we load them in a separate process which then communicates to host via RPC or just TCP on localhost. It has several important upsides:<ul><li>Isolation: crash in a plugin does not bring the whole application down.</li><li>Interoperability between languages: if RPC is the interface, do you care what language the plugin is written in?</li><li>Distribution: if plugins interface via the network, we can easily distribute them to run on different machines for gains in performance, reliability, and so on.</li></ul>Moreover, Golang makes this particularly easy by having a fairly capable RPC package right in the standard library: net/rpc.One of the most widely used RPC-based plugin systems is <a href="https://github.com/hashicorp/go-plugin">hashicorp/go-plugin</a>. Hashicorp is well known for creating great Golang software, and apparently, they use go-plugin for many of their systems, so it’s battle-tested (though its documentation could be better 😛)Golang-plugin runs on top of net/rpc but also supports gRPC. Advanced RPC protocols like gRPC are well suitable for plugins because they include versioning out-of-the-box, tackling the difficult interoperability problem between different versions of plugins vs. the main application.However, this is also not a perfect solution as we talk about the fourth fundamental of plugin systems- “Extension APIs”. In a complex system, a plugin might make lot of Extension APIs calls which will end up increasing the latency if we are making network calls via RPC or TCP.<h1 id="1c76">Conclusion</h1>Golang still has a long way to go when it comes to Dynamic-linking (shared library plugins). No solution discussed in this blog can be considered perfect. One needs to consider the pros and cons of each solution available as per their specific requirements.</article></body>

5 Tips and Tricks To Use Notion Like A Pro

This is how I use Notion.

I was curious by the buzz surrounding a rising trend among global note-takers: Notion, so I downloaded, explored, tested, and experimented with it in the hopes of sharing the fundamentals, reasonable, and better aspects of Notion.

I was not only surprised but also interested and astonished by how fantastic Notion is at being creative and practical.

Not only can you organize your finances and spending patterns, but you can also share your work, cross things off your to-do list, and provide tasks in real-time using Notion.

If you're new to using Notion and would like some assistance — just read the entire post.

1. The dark mode.

Many users adore the functionality of dark mode and insist on finding it in every software they use.

In reality, Android and iPhone have a dark mode for that reason!

If you fall into this category, you should know that using a dark mode in Notion is possible and straightforward.

Select dark from the selection after clicking Appearance in the Settings and Members section.

When utilising the keyboard shortcuts Command + Shift + L or Ctrl + Shift + L on a Mac, you can also employ this one of Notion’s tips and tricks.

It's also important to note that the web version does not support dark mode.

2. Quick look.

To get rapid access to your other pages, you may also search for a Notion page.

You can do this by using Control + P or Command + P, depending on the operating system, or by clicking the Quick search button in the top left corner of the screen.

5 Incredible Productivity Apps to Try In 2022 for Getting Things Done

Don't watch the clock. Do what it does. Keep going!

medium.com

This will open a little menu where you can quickly search for what you're looking for by typing!

3. Modify the typeface.

For many, altering the typeface is a question of taste; they want to pick one that looks prettier.

Of course, there's nothing wrong with it, but for those with dyslexia, the program's typeface is crucial.

The good news is that one of Notion's hints and suggestions is precisely that — to change the font, select "Style" from the menu in the top right corner of your screen.

4. Employ Covers and Icons.

You can add an icon, cover, and conversation topic at the top of each page to create the tone.

Emojis are described as icons by Notion. To set an icon for the page, select the add icon option.

Add a cover to incorporate a lovely background for the Notion page. Notion and Unsplash have joined to offer thousands of wallpapers for free.

5. Share pages with others.

You can share your creations with friends, acquaintances, coworkers at your place of business, or anyone else using another of Notion's tips and tricks.

Anyone with the page link can view it, so spread it around!

Furthermore, you may adjust the restrictions on this link to open your page to edits, comments, duplication, and even search engine visibility!

Finally, you can add particular contributors by entering their Notion account email addresses, like in Google Docs.

My decision to adopt Notion for Personal Productivity.

Regarding note-taking and personal productivity, I adore Notion!

I was able to streamline and get rid of three other apps when I started using Notion: a task tracker, a habit tracker, and a notes app.

3 Powerful Uses of Notion to Streamline Your Life

Do things only if they are great?

medium.com

My calendar has practically been supplanted by it as well!

Since I had been a devoted Evernote user before learning about Notion, I had been hesitant to switch.

My worries about switching platforms were unwarranted because Notion imported all of my Asana assignments and Evernote tasks without any issues.

I firmly believe Notion can assist you if you struggle with productivity, task management, or organizing. Follow the tips mentioned above to master Notion quickly.