Menu

Blog

Explore our insightful blog posts that delve deeper into the latest industry trends, best practices, and success stories. Gain valuable knowledge and stay informed about the ever-evolving landscape of digital transformation.

Advantages of Workplace Diversity

What comes to your mind when you think of ‘workplace diversity’? If someone would ask us the same question, we would have a myriad of things flashing in our mind. We would either have a long list to share or fail to bring up an aspect. Hence, we will narrow down the scope of the question.What are the things that you consider when talking about diversity in office?The first aspect will most probably be the gender ratio. The next in line would likely be the race. However, diversity is not limited to these physical attributes which are visible to us. Diversity also rests in aspects such as thoughts, beliefs, ethnicity and many more things which we might not know about a person in the first instance.You must have often come across the phrase ‘unity in diversity’ and though it is hard to believe, there can be a lot of advantages of diversity, especially in a workplace. In general, we might think that people who have common grounds get along well and the work gets smooth. However, studies have shown that diversity in the workplace can increase productivity. According to research conducted by MIT economist Sara Ellison, “Having a more diverse set of employees means you have a more diverse set of skills,” which she says, “could result in an office that functions better.”Even though the advantages of a heterogeneous team are undoubtedly beneficial yet to make everyone comfortable with the others calls for the manager to act swift. We at Nineleaps have a diverse team and we see its impact reflect during brainstorming sessions or meetings. We see a variety of opinion coming from different people and that helps us get a holistic view of the matter.Inclusion being one of our core values, everyone respects and appreciates the differences in opinions before arriving at the conclusions.Even when talking about the geographical aspect, Nineleaps can claim to be a mini India. We may be different in many ways but being a part of Nineleaps family we think ‘We fail as one and we succeed as one.’

Learn More >

A Healthy Comparison between SwiftUI and Storyboard

StoryboardStoryboard is a part of an interface builder which has been the most common way to create UI for iOS applications after its initial release with iOS 5. Any new iOS project has a Main. storyboard file by default.“The Interface Builder editor within Xcode makes it simple to design a full user interface without writing any code. Simply drag and drop windows, buttons, text fields, and other objects onto the design canvas to create a functioning user interface.” - Apple documentation about interface builders.A Storyboard in Xcode is a file that contains an empty canvas type screen. On it, we can drag and drop all types of objects available in the object library of Xcode. We can create almost everything from controllers to text fields to images to table views to buttons, all this without writing even a single line of code. You can add controller screens like a table view controller, navigation controller, etc. through drag and dropping from the object library. You can add segues and move through different screens. Even the smallest components like labels, images, text fields can be dragged and dropped from the object library.Advantages of Storyboard:It is easy to learn for even a beginner.With Storyboard, you can create a prototype of an app barely in an hour or two, which makes it easy to visualize the app without writing hundreds and thousands of lines of code.The storyboard object library has a vast collection of objects.It also has a large community support network.Drawbacks of Storyboard:Source control is difficult, since the storyboard code is in an XML type format it is very difficult to resolve merge conflicts as you cannot completely understand the code.While creating the application UI you have to keep in mind the Autolayout issues that they should work with all the supporting device sizes, you need to separately check on all devices using the preview option or running the app on each device.As the number of screens keeps increasing the management of storyboards can become very chaotic and as it forms a complex web-like structure.Swift UISwift UI was released with the release of iOS 13.“SwiftUI helps you build great-looking apps across all Apple platforms with the power of Swift — and as little code as possible. With SwiftUI, you can bring even better experiences to all users, on any Apple device, using just one set of tools and APIs.”-Apple documentation about swift UI.Swift UI is basically a toolkit released by apple to create UI’s in a declarative way.AdvantagesA single code can be used for all apple platforms like macOS, watchOS, iOS, etc.It offers an automatic live preview option which is like a hot reload that shows the changes made in the code immediately on view.There are no Autolayout issues as in the storyboard.It offers both drag and drops through the object library as well as writing code in the file facility.The code is simple and clean.Swift UI view elements can be easily reused, by creating smaller module files.It gives way to reactive programming by providing bindable objects.You can also mix UIKit and SwiftUI by using UIHostingController.DisadvantagesIt supports only iOS 13+ and Xcode 11+, so you cannot build lower version apps using this.It is still very new, there are not as many component options in the swift UI as in the storyboard object library. So you have to create custom views to fulfill requirements, eg: The search bar.It could be difficult for someone to switch from storyboard to swift UI as it is difficult to visualize the view hierarchy in the form of code.There is no direct way of migrating from storyboard to swift UI. This compels a developer to continue the use of the storyboard for existing apps and in lower versions.Since it is very new so there is less community support which is not the case for Storyboard.After looking at the pros and cons of both Storyboard and SwiftUI, building an app UI using storyboard is comparatively easier for a beginner, and has been for a very long time. But there are some flaws with it and those flaws have been taken care of in Swift UI.Swift UI also has its own set of flaws, but it can be seen that those flaws can be overlooked in terms of the advantages that it gives. Swift UI has a lot of potential for the future. You can also take a look at this Single view iOS application using swift UI if you want a taste of a SwiftUI application: iOS application using SwiftUI GitHub link.

Learn More >

Basics of Reactive Programming In Swift (RxSwift)

Reactive programming basically means relying on entities emitting elements, subscribing to its changes and reacting to those changes. So, reactive programming saves you from having to re-check states and manually putting conditions in your code. It remarkably reduces the code lines and makes the code cleaner and easier to manage. Most importantly, it manages asynchronous code execution in a very elegant manner owing to its observable-subscriber method.This article will give you a quick skim of elements of Reactive programming in just 4 min reading time. These are some basic terminologies that are used while writing code using the Reactive Programming paradigm.Observable: it is an entity that can be of any data type and emits elements to its subscribers on happening of every different type of event. Example: it emits error on an error event, emits the received value on an onNext event, etc.Observer: This subscribes to observables and listens for changes in them and takes the programmed action on any change.Dispose Bag: A dispose bag holds disposables in it. So basically, it is used for garbage management in the files. When we create subscriptions, we keep adding them to a global dispose bag in a file. So whenever that particular files’ memory is deallocated the subscriptions are properly disposed off from the dispose bag, so this ensures there are no memory leaks in the project.Subjects: Subjects acts dual way, both as an observable as well as an observer. There are four types of subjects :Publish Subject: it starts empty and only emits new elements to its subscribers. On completion, it still emits completion to its new subscribers.Behavior Subject: Starts with an initial value and replays it or the latest element to new subscribers.Replay Subject: Initialized with buffer size and will maintain a buffer of elements up to that size and replay it to new subscribers.Async Subject: Emits only the last next event in the sequence, and only when the subject receives a completed event.5. Relays: These wrap their respective subjects, but only accept and relay the next events. You cannot add a completed or error event onto relays at all, so they’re great for non-terminating sequences. There are two types of relays: PublishRelay and BehaviorRelay.6. Operators: there are different types of operators such as filtering operators, transforming operators, time-based operators which can be chained on observables using the dot operator so that the input from the observable can be modified as per requirement.Filtering operators: these operators let you filter out the results received from the data source. There are different type of filtering you can do on data using different operators, for example, .elementAt(index): it gives the element at a particular index, .skip(n): it skips n elements emitted by data source etc.Transforming operators: these operators let you transform data received from the data source into a different type. Some examples of this are .toArray(): this operator is used to transform the received elements into an array, .map(): allows you to enter a data type and change it to another data type.Combining operators: these operators let you combine results from observables. Example: .concat(): it is a static function that combines two observable sequences, .zip: it is used to couple two operations/requests and aggregate a result once both are done.Time-based operators: these operators are used to do operations like buffering and replaying data. Example: replay(): This operator creates a new sequence which records the last ’n’ emitted by the source observable, interval(schedulers: ): it produces an infinite observable sequence of Int values (effectively a counter) sent at the selected interval on the specified scheduler.7. Schedulers: A scheduler is a context on which a process takes place. So schedulers here are used to shift subscription contexts. There are different types of schedulers like MainScheduler, Concurrent Schedulers etc. To Switch Schedulers, we use these two operators:subscribeOn(): we can switch threads by using this operator.observeOn(): this operator changes the scheduler where the observation happens.That’s all about the basics of Reactive Programming and a sneak peek into Rxswift.I hope it was helpful enough to give you a kick start on reactive programming and rxswift!Please share your valuable feedback in the comments section and also give the article a Clap if it’s worth it!

Learn More >

How to Master Remote Productivity

An offshoot of the process of modernization of work, Work-from-Home has been a luxury afforded to employees by organizations taking the digital route. But for the modern employee arises a modern problem. How can one work with absolute concentration when there are so many distractions? That’s why we have put together some tips that will help you master remote productivity. Be realistic about your goalsThe first order of business is to understand that working in an office space and at home are two completely different things. There are far too many responsibilities at home apart from our daily workload. Your work goals for the day need to be realistic, definite and easy to achieve. This method is comparatively better than aiming for unreachable targets and feeling upset about not being able to achieve them.Work in short burstsWhile working from home, there are distractions that are both internal and external. External distractions can be avoided but a few of these internal distractions have to be addressed. It could be washing clothes, making lunch, feeding your pet etc. This changing dynamic often leads to the loss of focus. Try getting in 60 minutes of focused work followed by a short break to maintain your concentration levels.Manage distractionsWith reference to the previous point, distractions come across in different ways. You need to proactively manage these distractions during your work breaks to maintain your concentration levels and increase your overall productivity.Be socially distant but communicateIt is understood that working in an office demands you to be sociable. You end up meeting people every day and establish a working relationship with them. But you need to understand that like every relationship, a certain amount of work needs to go into this one as well. By establishing communication with your colleagues, you can work on your work relationships and keep yourself updated with your project as well as the organization.Plan as if you are in the officeThe office gives you a space to push away other thoughts and focus on your work. You establish a strict schedule and stick to it. Working from home does not give you this environment. In order to increase your productivity, it is advisable that you emulate your environment as that is your office. For example, If you have an online calendar, create personal events and reminders that tell you when to shift gears and start on new tasks.Work at your most productive.Choose the time that you are at your most productive and capitalize on that period to knock off tasks that need your full involvement. In the periods when you are less productive, work on ticking off the easier tasks of your workload.

Learn More >

Embracing Green Initiatives: A Corporate Responsibility

To ensure a greener tomorrow a growing number of nations across the world are taking significant steps towards various "green Initiatives" like waste management and developing sources for renewable energy. USA recycles about 35% of Municipal Solid Waste (MSW) and 13% is combusted for energy production. On the other hand, Europe is targeting to recycle 65% by 2030.In addition, as we continue to face growing environmental challenges and air pollution, various non-governmental organizations and civil societies have come together to raise environmental awareness all around the world. The issue has also garnered considerable media attention and enthusiasm amongst prominent and influential people across walks of life, advocating green initiatives and urging people to adopt sustainable practices.The ‘go green’ or ‘thin green’ movement has found substantial interest amongst organizations too. Environmental practices, once viewed as a mandatory compliance necessity, are now being embraced as green movement and gaining momentum worldwide.Building an environmentally friendly companyAn average business consumes approximately 3.6 tons of paper, 480,000 m3 of water and 1,175,000 KWH per year. Any amount of sustainability practices in businesses can help reduce these numbers considerably.While more companies across the world are now shifting their focus on integrating green initiatives with business operations, there are still many organizations who do not quite comprehend the criticality of the issue. In some cases, they do not fully understand green projects and sustainability efforts, making it difficult for them to adopt such initiatives.As natural resources continue to deplete and various environmental issues multiply, going green is becoming crucial, where organizations have a major role to play. They need to commit themselves to reducing their environmental footprint and ensuring superior waste management.Organizations who recognize that biodiversity is diminishing have devised various programs to promote environmentally responsible practices. These include educating, communicating, engaging, and encouraging participation in the green process. More and more businesses need to adopt such practices. Besides, green initiatives have broader effect that goes beyond just reducing your impact on the environment. Running an environmentally friendly business can significantly improve overall operational efficiency and optimize resource utilization and cost. Simple measures such as turning off monitors and lights, when not in use, can save energy and utility costs, and in turn increase company’s bottom line. Reusing ball point pens instead of throwing them away or using ceramic coffee mugs instead of paper cups can help lower the budget spent on these resources and reduce plastic use and paper waste.In addition, following sustainability initiatives can help organizations bring its employees, vendors and other stakeholders into the fold of the green movement, force multiplying sustainable practices.Touting green and sustainable practicesAt Nineleaps we are in the process of implementing sustainability projects to fulfill our responsibility towards environment and society at large. Key focus of our green initiative is to raise awareness amongst our employees and motivate them to adopt sustainable practices at home and work.We will begin with simple green practices, scaling it up overtime to become more eco-friendly organization not only in our operations but also in the products and services we support. And in the process, develop a workforce that understands the importance of going green and our corporate responsibility towards society.

Learn More >

Deep Dive into Jupyter Notebooks to Master ML Analysis

In case you stumbled on my blog series, here’s a brief about my blogging activities. I make deep dives on the important machine learning algorithms. After completing an overview of machine learning I had started with linear regression. Now before moving on, I want to take a kind of break from the flow and discuss the tooling that an everyday machine learning engineer uses. In fact, I would be specifically talking about the most important tool that he/she would need in their day to day work: Jupyter Notebook. If you have been interested in machine learning at least for some time then I am sure you must have heard of this tool and actively using it. Through this post, I am hoping that I will be able to shed light on some interesting ways in which you can use jupyter notebooks to take your analysis to the next level.HistoryBut first, let’s look at the origin of this awesome software. In the data-science field as well as the broader scientific community, the kind of analysis that has been resorted to has been largely exploratory. Not only is the output important but the methodology and the way the output is generated is also important. Previously it was difficult to share the line of thinking, hence, there was always a need for such a tool which facilitates it. Therefore, the IPython Notebook was developed in 2011 by a team of researchers under Fernando Pérez and Brian Granger. It was then called IPython because the kernel could only execute Python code. In 2014 the Project Jupyter started as a spin-off project from the IPython project. In the new notebooks, the kernels were separate from the frontend and support for other languages apart from Python was brought in.Just as a side note, Jupyter is an acronym for Julia, Python and R, signifying that the project creators want to encompass the whole sky of machine learning under its umbrella and provide the power of lightning and flash to all its users.:)Version ControllingOnce you start maintaining jupyter notebooks for reproducible results, it is important to have an effective storing mechanism. Github is an excellent platform to store and view the notebooks as it renders the notebook when you open the respective file link on any web browser. There are two caveats though. First, is if you have a lot of JavaScript in your notebook, then they are not rendered in Github. You will then need to see them on your local machine. Other than that sometimes differences in code are tough to see and hence, the changes with the previous code are pretty hard to see due to the file structure of the ipynb files.The solution is to save python files with the jupyter notebook so that the differences in code can be tracked easily as well. This can be done by editing the config file:~/.ipython/profile_nbserver/ipython_notebook_config.py ### If you want to auto-save .html and .py versions of your notebook: # modified from: https://github.com/ipython/ipython/issues/8009 import os from subprocess import check_call   def post_save(model, os_path, contents_manager): """post-save hook for converting notebooks to .py scripts""" if model['type'] != 'notebook': return # only do this for notebooks d, fname = os.path.split(os_path) check_call(['ipython', 'nbconvert', '--to', 'script', fname], cwd=d) check_call(['ipython', 'nbconvert', '--to', 'html', fname], cwd=d)   c.FileContentsManager.post_save_hook = post_saveview rawipython_notebook_config.py hosted with ❤ by GitHubThis would save a .py and .html file with each notebook saved. Then the differences in the code can be easily shown in the console.Saving images as a separate file also has a lot of benefits as you can compare the differences between the two. Click on this link and see how the differences in the images can be easily shown.Two kinds of notebooksSince jupyter notebooks can be used as an exploratory tool as well as a final document that can be delivered and shown to the customer, it is highly advisable for analytics teams to have two kinds of folders for a specific use case. One can be named develop where exploratory analysis can be kept while the other can be named deliver to house the final notebooks. So you will have the following folder structure.– develop– ––+ analysis1.ipynb+ analysis1.py+ somefig.png– deliver–+ final_analysis.ipynb+ final_analysis.py+ fig1.pngMagicsThere are a lot of magics that can be used in jupyter notebooks. A listing of all the magics will make this post too long, hence, will only focus on the ones that I find most useful in my day to day work.The first one is using the magic bash. Bash commands make it easy to see the files in the current directory and also download files and other simple bash commands without leaving the comfort of the browser. You can also show the state of the directory where you are probably downloading some file and would like to show that the file is present in some remote directory like s3 and you will need to download the file.view rawbash_magics.ipynb hosted with ❤ by GitHubAnother one I like is showing math equations. Since we as data scientists work with a lot of algorithms, we need to articulate the algorithms that we use for other engineers who we are working with. Hence %%latex magic really helps us in that manner.view rawlatex.ipynb hosted with ❤ by GitHubStructuring a Jupyter NotebookIn the beginning, there should be the imports and the dependencies. For Python, imports should be ordered in the normal PEP8 way. i.e.,1.standard libraries2.related third-party imports3.local application/library/module importsNext, the version information should be given on at least the main dependencies like numpy, scipy, pandas etc.view rawstarting_notebook.ipynb hosted with ❤ by GitHubOnce you have reached near the end of your notebook you should consider two things.Is my notebook too big? In case its too big, then probably it will not be clear to the reader what the big picture is. Hence, probably you should consider breaking the notebook into separate notebooks. To do that you can take help of the FileLinks function.view rawlinking.ipynb hosted with ❤ by GitHubJupyter Notebooks are meant to be stories about data and hence should have a conclusion summarizing the main points and what has been discussed.DebuggingIf the code that you are trying to debug lands in the realm of pure python, then you can employ the age-old python debugging tools of pdb. The pdb commands and methods work in the jupyter notebook as well.view rawdebugging_using_python.ipynb hosted with ❤ by GitHubIn my experience pdb should help you a great deal while debugging your models. This is based on the assumptions that you create your models in python. In case you are creating your models in some other language then you will need to use the debugging tools for the respective language, but I am going to assume that jupyter would work the same way in case the language is an interpreted one like R, Julia, etc. In case you are finding some other kind of errors that look more like weird matrix issues, then probably the shape of the data that you are passing is wrong and you need to look closer at how you are building your matrices.ProfilingSince you will be dealing with huge amounts of data, it is a good thing to know such things as memory consumption, time spent in executing the cells, especially the cells that are doing most of the heavy lifting, and so on.%%time will tell you the amount of time needed to run the cell.view rawprofiling_time.ipynb hosted with ❤ by GitHubYou can also use line profiler or see how much memory the cells are taking. For that, you will need to install line_profiler and memory_profiler depending on your requirement. Then you can load the extensions.view rawprofiling_line_memory.ipynb hosted with ❤ by GitHub

Learn More >

Prolog Logic Programming: A Detailed Explanation

Prolog logic programming language is a general-purpose programming language. If you have never heard of this language and are a SQL aficionado, you will recognize the way of writing code in this language, which feels quite like a query. This is a declarative language or a rule-based language like SQL. Note that in “normal” languages that you encounter, like C, Java, and Python, you generally write out the ways in which you retrieve the data or do the computation. Here, you will just be defining what you want instead of writing out explicitly how to get it. Feels wonderful, isn’t it? Now, since this is a vast language by itself, only a minuscule part will be looked at.1.install swipl2.take a look at some basic examples to have some idea on how prolog code looks like3.ruminate on some basic ways in which we can reason about codeSWIPLSWI-Prolog is one of the most comprehensive implementation for prolog. It is also very widely used. You can use the SWI-Prolog interpreter to run the programs. To install the interpreter in ubuntu you can run the following commands.sudo add-apt-repository ppa:swi-prolog/stablesudo apt-get updatesudo apt-get install swi-prologNow, create a new hello.pl and type the below lines: /* * usage: swipl -q -f prolog_hello.pl -t main */ main :- write("Hello world!"), nl, fail.view rawprolog_hello.pl hosted with ❤ by GitHubYou have created a hello world program for prolog. In the terminal, run the following command to run this file and you should get the output in the terminal.➜ swipl -q -f hello.pl -t mainHello WorldSome code examplesTake a look at some code samples to understand the flow of logic in a prolog code. To show relationships between data, write in the following format.verb(noun1, noun2)which means that there is a relationship from noun1 to noun2 via relationship verb . Using this define the following relationships. has(jack,apples). % jack has apples. has(jack,plums). % jack has plums. has(ann,plums). % ann has plums. has(dan,money). % dan has money. fruit(apples). % apple is fruit. fruit(plums). % plums is fruit.view rawprolog1.pl hosted with ❤ by GitHubThis is logic programming where the facts and rules of the problem domain is defined. The following code will list the members of fruit class.https://gist.github.com/infinite-Joy/infinite-Joy/0cb2efac38507593cd0380e6d504e2aeThis is called a query. Save this to a listing.pl file and then execute the query. The command is written as:swipl -q -f -t➜ swipl -q -f listing.pl -t mainfruit(apples).fruit(plums).This shows a listing of all the relationships in the data.Similarly, based on the existing relationships, write the names of the people who have apples or plums. main :- has(X,apples), % who has apples has(Y,plums), % who has plums write(X), % write the apple lovers put(10), % new line write(Y), % write the plum lovers nl, halt. % new line and haltview rawprolog3.pl hosted with ❤ by GitHubRun the file in the terminal using the interpreter➜ prolog swipl -q -f listing1.pl -t mainjackannYou can find the whole file in this github gist.Now as an exercise can you find the people who have both apples and plums. Share the gist in the comments below.In case you found this interesting and would like to talk more on this, just drop me a message @alt227Joydeep. I would be glad to discuss this further. You can also hit the like button and follow me here, on Medium.

Learn More >

Graphs in Python and Prolog for Shortest Paths

Graphs are omnipresent in today’s computing world. From implementing compilers to computer games to maps, you will need to use graphs everywhere. In case you are a programmer and not sure what is a graph or any of the major graph algorithms, please take a look at these books on graph algorithms. In this blog, we will be talking about graphs in python and prologGraphs Let’s build a graph and see what the solution using standard techniques look like. First, let’s define a graph. We will define the graph in Python and try to visualize it as well.graph = {'a': {'w': 14, 'x': 7, 'y': 9},'b': {'w': 9, 'z': 6},'w': {'a': 14, 'b': 9, 'y': 2},'x': {'a': 7, 'y': 10, 'z': 15},'y': {'a': 9, 'w': 2, 'x': 10, 'z': 11},'z': {'b': 6, 'x': 15, 'y': 11}}This can be visualized in Python using the libraries networkx and matplotlib.%matplotlib inlineimport networkx as nximport numpy as npimport matplotlib.pyplot as pltimport pylab# initialise a directed graphG = nx.DiGraph()# add the edges and the weights.G.add_edges_from([('A', 'W')], weight=14)G.add_edges_from([('A', 'X')], weight=7)G.add_edges_from([('A', 'Y')], weight=9)G.add_edges_from([('B', 'W')], weight=9)G.add_edges_from([('B', 'Z')], weight=6)G.add_edges_from([('W', 'A')], weight=14)G.add_edges_from([('W', 'B')], weight=9)G.add_edges_from([('W', 'Y')], weight=2)G.add_edges_from([('X', 'A')], weight=7)G.add_edges_from([('X', 'Y')], weight=10)G.add_edges_from([('X', 'Z')], weight=15)G.add_edges_from([('Y', 'A')], weight=9)G.add_edges_from([('Y', 'W')], weight=2)G.add_edges_from([('Y', 'X')], weight=10)G.add_edges_from([('Y', 'Z')], weight=11)G.add_edges_from([('Z', 'B')], weight=6)G.add_edges_from([('Z', 'X')], weight=15)G.add_edges_from([('Z', 'Y')], weight=11)# value map so that we have different colors for different nodesval_map = {'A': 1.0,'B': 0.9,'W': 0.8,'X': 0.7,'Y': 0.6,'Z': 0.5}values = [val_map.get(node, 0.45) for node in G.nodes()]edge_labels=dict([((u,v,),d['weight'])for u,v,d in G.edges(data=True)])red_edges = [('A','Y'),('Y','W'), ('W', 'B')]edge_colors = ['black' if not edge in red_edges else 'red' for edge in G.edges()]node_labels = {node:node for node in G.nodes()}plt.axis('off')fig = plt.figure(1)fig = plt.figure(num=1, figsize=(10, 10), dpi=100)fig.set_size_inches(10.5, 10.5)# draw it out.pos=nx.spring_layout(G)nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels)nx.draw_networkx_labels(G, pos, labels=node_labels)nx.draw(G,pos, node_color = values, node_size=1500,edge_color=edge_colors,edge_cmap=plt.cm.Reds)xmax = 1.2ymax = 1.1plt.xlim(-0.1, xmax)plt.ylim(-0.1, ymax)pylab.show()pylab.close()del figTo find the shortest path using python you probably will need to implement a known algorithm such as Dijkstra. You can try to look at the code linked here which I would argue is huge. The implementation will be the same in almost all object oriented and procedural code. But in Prolog, due to many things being handled by the compiler, the code gets reduced a lot.No need to write node classes or priority queuesJust write the relationships between the nodes and edges in a simple, clean manner.edge(a,w,14).edge(a,x,7).edge(a,y,9).edge(b,w,9).edge(b,z,6).edge(w,a,14).edge(w,b,9).edge(w,y,2).edge(x,a,7).edge(x,y,10).edge(x,z,15).edge(y,a,9).edge(y,w,2).edge(y,x,10).edge(y,z,11).edge(z,b,6).edge(z,x,15).edge(z,y,11).Now, looking at the code that crunches the numbers.findapath(X, Y, W, [X,Y], _) :- edge(X, Y, W). % findapath between X and Y has weight W  if there is an edge between X and Y of weight Wfindapath(X, Y, W, [X|P], V) :-                % else findapath between X and Y        \+ member(X, V),                       % is trueedge(X, Z, W1),                        % if we can findapath between X and Z with weight W1findapath(Z, Y, W2, P, [X|V]),         % and there is findapat between Z and Y of weight W2W is W1 + W2.                          % where W is W1 + W2:-dynamic(solution/2).findminpath(X, Y, W, P) :-\+ solution(_, _),findapath(X, Y, W1, P1, []),assertz(solution(W1, P1)),!, findminpath(X,Y,W,P).findminpath(X, Y, _, _) :-findapath(X, Y, W1, P1, []),solution(W2, P2),W1 < W2,retract(solution(W2, P2)),asserta(solution(W1, P1)), fail.findminpath(_, _, W, P) :- solution(W,P), retract(solution(W,P)).main :-    findminpath(a,b,W,P),    write('the minimum cost that we must pay.'),    write(W),    nl,    write('path that has the minimum cost.'),    write(P),    nl, halt.A huge shout-out to Rodney who has made a brilliant description of the above code.Last ThoughtsIn many cases involving graphs, Prolog helps us in writing clear and concise code. It is easier to express some data structures using Prolog that needs more careful code writing with intricate testing to come to the same solution.In case you found this interesting and would like to talk more on this, just drop me a message @alt227Joydeep. I would be glad to discuss this further. You can also hit the like button and follow me here, on Medium.References:Wikipedia. PrologPython Patterns — Implementing GraphsDjikstra algorithm implementationPython graph implementationFind path between two nodes in graph. Prolog discussion threadSO. create graphs using networkx

Learn More >

Best Practices to Navigate Existing Project Work

Whether you need to develop a new feature, fix a bug, refactor the existing code or you just got on board of a project that is already running, as developers we have all had an existing project work at some time or are required to do so every now and then.Now you may have been able to deliver the project without any roadblocks, in which case you can use this post as best practices to follow for future projects. But most of the time developers face various challenges as they fail to ask relevant questions and clarify before starting work. Lack of thorough understanding of the project and its requirements often leads to assumptions making it difficult to approach the work systematically.To avoid such roadblocks and ensure desired results you should be aware of the approach to work on an existing project and the initial steps you need to follow before you start coding.Here’s a list of best practices that might help you initiating work on an existing project effectively.Get the right accessOne of the common problems is access permission issues that can delay deliverables. Before you begin work on a project ensure that you have the right developer-level access. And also have contact details of the relevant person in your team at hand in case you run into any access issues. Once you get your username and password do a test run to reconfirm whether you have the right access required for the job.Understand the projectIt is crucial to have a thorough understanding of the project before you start working on it. Some of the key questions listed below can help you gather right and enough information that can help you understand the project better. These questions include:Why is the project running?What problem is it solving?How is it solving the problem?Who are the end-users of your project?How frequently is a feature delivered in your project?What SDLC process is followed?Besides, clarify the requirements and do not hesitate to ask questions to your team members and clients. In addition, follow these basic yet critical steps to get a complete visibility into the project:Make sure you have access to proper documentation such as:README file, Data Flow Diagrams, Architectural Diagrams etc.Code review checklist, Non-Functional Requirements checklist, and Definition-of-Done checklist.Ways of working, dos and don’tsSecurity policies documentKnow about the version control that is used in your project (like GIT, TFS).Go through the project structure, identify the tech stack, the frameworks and the 3rd party libraries and packages used.Understand why certain libraries are being used.Be aware of the builds and deployment process, whether manual or automated.Understand the complete structure and flow of control in your project. You can refer to the documentation and make your own flowcharts, if necessary. Get them reviewed by your team members to reconfirm your understanding of the project.Request knowledge transfer sessions and invest in code time if you are starting something that is new for you but not for your team members.Set up the development environmentEvery project will have some external dependencies due to which it becomes a challenge to set up the project in dev-environment, in order to run and test locally.It is easier to solve this problem if you have a dockerized project (read more on docker here), as used in this project, so that you can run and test the project locally.Another way to solve this problem is to do a dev-environment setup manually. You can find the steps for doing the same in the README.md file, but that might not be enough.Sometimes after setting up the dev-environment, your project may not function in an expected way, and may end up throwing errors. In that case, trace the error, look up online or discuss with the team. When you find the solution, log it in a shared sheet so that others can benefit from it.These are some of the best practices I have listed on the basis of my experiences and challenges that I faced while working on existing projects.If you too have come across an issue which you think might later become a roadblock, feel free to share with the team along with the resolutions or alternatives.

Learn More >