#hire clojure developer

[hiringjournal]

Why Hire a Clojure Developer? Key Benefits of Using Clojure for Your Next Project

For a web or enterprise application, Clojure may not be the first language that springs to mind. However, it's a strong option for projects that demand simplicity, scalability, and great performance. Hiring Clojure engineers is becoming increasingly popular as more tech businesses look for code that is concurrent, tidy, and maintainable.

Clojure, which is based on the Java Virtual Machine (JVM), combines the flexibility and brevity of a contemporary Lisp with the strength and reliability of Java. Clojure might be just what you need if you are developing a new reactive application, data processing system, or backend. 

Modern Performance, Functional Reliability, and Simplicity in One Elegant Language

Clojure is a dynamic, functional language that prioritizes concurrency, simplicity, and immutability. Clojure, in contrast to conventional object-oriented languages, enables programmers to create reliable systems with less complexity and fewer side effects.

Hiring Clojure developers gives you access to a philosophy that prioritizes dependable logic, clear abstractions, and performance under pressure. Clojure's emphasis on pure functions and immutable data structures results in fewer errors and simpler testing.

Top Reasons to Use Clojure in Your Next Project

Immutable by default

Code that is immutable is more predictable. Writing functions that don't change state is encouraged by Clojure, which lowers problems and facilitates debugging and scaling applications.

Seamless Java interoperability

Clojure has complete access to Java libraries and operates on the JVM. This implies that you can write new logic in a more expressive language while utilizing pre-existing Java code.

Concurrency simplified

Concurrency was considered in the design of Clojure. Developers can construct concurrent code without the drawbacks of conventional multithreading by utilizing built-in features such as software transactional memory and agents.

REPL-Driven development

The REPL (Read-Eval-Print Loop) is a tool used by Clojure developers for interactive code writing and testing. Faster feedback loops and more fruitful development sessions are the outcomes of this.

These characteristics are strategic advantages for software organizations that prioritize agility and long-term maintainability.

Finding and Hiring the Right Developer

Hiring Clojure developers with practical experience and a solid foundation in functional programming is crucial because Clojure is a more specialized language than other languages.

They ought to feel at ease collaborating with:

The environment of JVM

Patterns of function and recursion

Frameworks for websites such as Luminus

Data libraries such as ClojureScript (for frontend) or core.async

Be ready to hire remote talent because many highly qualified Clojure professionals prefer working remotely. This broadens your search to include engineers from around the globe who are used to working asynchronously and are frequently involved in open-source groups.

Use an IT Staffing Agency to Simplify the Search

It can be challenging to locate Clojure talent on conventional job boards. Reaching pre-screened developers with the necessary experience might be facilitated by collaborating with an IT staffing agency. 

In addition to streamlining the employment process, agencies guarantee that technical proficiency, communication requirements, and cultural fit are fulfilled. This can significantly shorten time-to-hire and boost long-term placement success rates for expanding IT organizations.

Final Thoughts

Clojure is a strategic choice for contemporary, scalable, and maintainable applications; it’s not only a specialized language. Hiring experienced Clojure developers will result in agile development, cleaner code, and long-term dependability.

Clojure provides a sophisticated and practical answer to challenging problems for tech companies willing to look outside the box.

[stuckthemarket]

Know More About React Native Security  

Reactive Native is a cross-platform app development framework that was founded in the year 2015. Since then it has emerged as a preferred framework by most developers across the globe. Given that react native is capable of refreshing the UI without any interruptions, it has quickly taken over other app development frameworks. In addition, developers can also integrate react native security in the applications they are developing which will ensure that they are safe and secure. 

React is also capable of offering interactive and intuitive ways of building interfaces. Even using components of the smaller pieces of code, react is capable of building complicated applications. It allows developers to use a variety of techniques of web technologies. For example, JavaScript can also be used along with React to build a cross-platform application. Moreover, JavaScript security can also be used for React apps. 

Things You Need to Know about React Native Security  However, if you plan on using react native for your application, then it is advisable to understand a few things about react native before you get started. Moreover, if you’ve never used react native before, it becomes even more imperative to know some things before you begin. The following list will help you in forming an idea about react-native: 

1)OS Changes are not troublesome 

Using a library that makes use of the operating system SDK API, you will realize that your codebase does not depend directly on SDK. Consequently, you will face less stress when there are any major iOS releases, there will be less breakage and deprecation of the APIs, conforming to or changing to new language features is not required, and adapting to new tools won’t be necessary either. Thus, you can completely be assured that you won’t have to face these problems and take action when you want to rather than when an external factor forces you to. 

2) Hassle-free CSS 

If you are making use of CSS on the web, chances are that you will have to pick a language that is of a higher level, create a build pipeline and even go through browser-specific prefixing. You will also need to minify everything and even ensure that consistency in style and layout is maintained across all browsers. However, react-native chooses JavaScript as the language of styling. This means that you will be receiving variables, mixins, inheritances, and every other imaginable option. Consistency can also be maintained without any hassles. 

3)Feel free to use any language 

You can choose to use any language that is compatible with JavaScript. For instance, some people love Clojure and will always try to look out for it given how vibrant it is. Similarly, you can use any language you prefer or like. Since react native is cutting-edge technology, you will always get to experience the best of whatever comes with react native. 

Conclusion 

With React Native you can also update your codebase remotely. You can easily fix bugs, create new content and even launch new features without going through the entire app store process. Apart from this know-how, you should gain an in-depth understanding of react-native. It is advisable to hire a company that has expertise in the area to build a React native app for you. 

[webbleu01]

How to Install Node.js on Linux Using Different Methods?

Node JS is an open-source, back-end Javascript code outside a web browser. Here are the steps on how to install Node.js on Linux using various methods. hire node js develoepr

Node.js is a cross-platform that runs on the V8 engine and executes Javascript code outside a web browser. It also allows developers to use Javascript to write command-line tools and run scripts server-side to produce dynamic web page content before the page is sent to the user’s web browser. 

.js is a standard filename extension for Javascript code, but Node.js doesn’t refer to a file in this context.

Overview of Node.js

Node.js allows the creation of web servers and networking tools using Javascript and modules that handle various core functionalities. Javascript is the only language that Node.js supports natively. As a result, Node.js applications can be written in Clojure script, Dart, and others. It is officially supported on macOS, Linux, and Microsoft Windows 8.1. 

Node.js brings event-driven programming to web servers and allows the development of fast web servers in JavaScript. It connects the ease of a scripting language with the power of Unix network programming. It was built on top of Google’s V8 Javascript engine since it was open-sourced under the BSD license. The Node.js developer community has developed web frameworks to accelerate the development of applications. The frameworks include Socket.IO, Derby, Express.js, Feathers.js, and others. 

Modern desktop IEDs provide debugging features for Node.js applications. These IDEs include JetBrains, Microsoft Visual Studio, or TypeScript with Node definitions. It is supported across several cloud hosting programs like Google Cloud Platform, Joyent, and others.

Install NodeJS on Linux Using NVM

This is the best way to install Node.js. NVM is a bash script used to manage multiple Node.js versions. It allows us to install and uninstall Node.js and switch from one version to another. The best thing is we can install any available Node.js version of our choice using NVM.

Install Node.js on Linux using your distribution’s package manager

It is available in the default repositories of most Linux distributions. If you want to have a stable Node.js on your Linux, you can install it using the distribution package manager.

On Arch Linux and its derivatives like Antergos, Manjaro Linux, run the “$ sudo pacman -S nodejs npm” command to install it. 

On RHEL, CentOS, you need to enable the EPEL repository first. $ sudo yum install epel-release and then install Node.js using $ sudo yum install nodejs npm command.

For More Info: mobile app development company in india

React Native Development Company

web development

[holyjak]

Some good tips for what to check when hiring a Clojure dev.

[yahoodevelopers]

Apache Storm 2.0 Improvements

By Kishor Patil, Principal Software Systems Engineer at Verizon Media, and PMC member of Apache Storm & Bobby Evans, Apache Member and PMC member of Apache Hadoop, Spark, Storm, and Tez

We are excited to be part of the new release of Apache Storm 2.0.0. The open source community has been working on this major release, Storm 2.0, for quite some time. At Yahoo we had a long time and strong commitment to using and contributing to Storm; a commitment we continue as part of Verizon Media. Together with the Apache community, we’ve added more than 1000 fixes and improvements to this new release. These improvements include sending real-time infrastructure alerts to the DevOps folks running Storm and the ability to augment ingested content with related content, thereby giving the users a deeper understanding of any one piece of content.  

Performance

Performance and utilization are very important to us, so we developed a benchmark to evaluate various stream processing platforms and the initial results showed Storm to be among the best. We expect to release new numbers by the end of June 2019, but in the interim, we ran some smaller Storm specific tests that we’d like to share.

Storm 2.0 has a built-in load generation tool under examples/storm-loadgen. It comes with the requisite word count test, which we used here, but also has the ability to capture a statistical representation of the bolts and spouts in a running production topology and replay that load on another topology, or another version of Storm. For this test, we backported that code to Storm 1.2.2. We then ran the ThroughputVsLatency test on both code bases at various throughputs and different numbers of workers to see what impact Storm 2.0 would have. These were run out of the box with no tuning to the default parameters, except to set max.spout.pending in the topologies to be 1000 sentences, as in the past that has proven to be a good balance between throughput and latency while providing flow control in the 1.2.2 version that lacks backpressure.

In general, for a WordCount topology, we noticed 50% - 80% improvements in latency for processing a full sentence. Moreover, 99 percentile latency in most cases, is lower than the mean latency in the 1.2.2 version. We also saw the maximum throughput on the same hardware more than double.

Why did this happen? STORM-2306 redesigned the threading model in the workers, replaced disruptor queues with JCTools queues, added in a new true backpressure mechanism, and optimized a lot of code paths to reduce the overhead of the system. The impact on system resources is very promising. Memory usage was untouched, but CPU usage was a bit more nuanced.

At low throughput (< 8000 sentences per second) the new system uses more CPU than before. This can be tuned as the system does not auto-tune itself yet. At higher rates, the slope of the line is much lower which means Storm has less overhead than before resulting in being able to process more data with the same hardware. This also means that we were able to max out each of these configurations at > 100,000 sentences per second on 2.0.0 which is over 2x the maximum 45,000 sentences per second that 1.2.2 could do with the same setup. Note that we did nothing to tune these topologies on either setup. With true backpressure, a WordCount Topology could consistently process 230,000 sentences per second by disabling the event tracking feature. Due to true backpressure, when we disabled it entirely, then we were able to achieve over 230,000 sentences per second in a stable way, which equates to over 2 million messages per second being processed on a single node.

Scalability

In 2.0, we have laid the groundwork to make Storm even more scalable. Workers and supervisors can now heartbeat directly into Nimbus instead of going through ZooKeeper, resulting in the ability to run much larger clusters out of the box.

Developer Friendly

Prior to 2.0, Storm was primarily written in Clojure. Clojure is a wonderful language with many advantages over pure Java, but its prevalence in Storm became a hindrance for many developers who weren’t very familiar with it and didn’t have the time to learn it.  Due to this, the community decided to port all of the daemon processes over to pure Java. We still maintain a backward compatible storm-clojure package for those that want to continue using Clojure for topologies.

Split Classpath

In older versions, Storm was a single jar, that included code for the daemons as well as the user code. We have now split this up and storm-client provides everything needed for your topology to run. Storm-core can still be used as a dependency for tests that want to run a local mode cluster, but it will pull in more dependencies than you might expect.

To upgrade your topology to 2.0, you’ll just need to switch your dependency from storm-core-1.2.2 to storm-client-2.0.0 and recompile.  

Backward Compatible

Even though Storm 2.0 is API compatible with older versions, it can be difficult when running a hosted multi-tenant cluster. Coordinating upgrading the cluster with recompiling all of the topologies can be a massive task. Starting in 2.0.0, Storm has the option to run workers for topologies submitted with an older version with a classpath for a compatible older version of Storm. This important feature which was developed by our team, allows you to upgrade your cluster to 2.0 while still allowing for upgrading your topologies whenever they’re recompiled to use newer dependencies.

Generic Resource Aware Scheduling

With the newer generic resource aware scheduling strategy, it is now possible to specify generic resources along with CPU and memory such as Network, GPU, and any other generic cluster level resource. This allows topologies to specify such generic resource requirements for components resulting in better scheduling and stability.

More To Come

Storm is a secure enterprise-ready stream but there is always room for improvement, which is why we’re adding in support to run workers in isolated, locked down, containers so there is less chance of malicious code using a zero-day exploit in the OS to steal data.

We are working on redesigning metrics and heartbeats to be able to scale even better and more importantly automatically adjust your topology so it can run optimally on the available hardware. We are also exploring running Storm on other systems, to provide a clean base to run not just on Mesos but also on YARN and Kubernetes.

If you have any questions or suggestions, please feel free to reach out via email.

P.S. We’re hiring! Explore the Big Data Open Source Distributed System Developer opportunity here.

[kodehash12]

How You Can Hire Chatbot Developers Efficiently

In essence, a chatbot is a bot that uses artificial intelligence and machine learning to respond to user questions and carry out simple activities on multiple platforms including Facebook, Twitter, Instagram, and other websites or apps. The chatbot not only minimizes human work but also gives businesses that frequently engage with customers a cost-effective option. These days, a lot of businesses, including startups, use chatbots to drive consumer communication, which increases productivity.

Employ chatbot designers who have a strong command of the field if you want to integrate chatbot applications for your social media and other platforms. Since this is still a specialized field, there aren't many top-notch chatbot developers available for hire. Chatbot development company in USA knows the need for chatbot development and provide the best chatbot services.

This is why it's crucial to have a solid hiring process in place to assist you in finding and selecting the top chatbot developers who can accommodate your company's needs.

The qualities to look for in a chatbot developer:

Technical mastery of the majority of these abilities and frameworks is required of a skilled chatbot developer to create an application that is both highly scalable and effective.

A solid command of various programming languages:

The creators of chatbots should be extremely knowledgeable in a variety of programming languages, including Java, PHP, Python, Ruby, Clojure, and C#. It is beneficial to have a developer with exceptional mastery over a variety of languages so they can assist you in scaling up as and when the requirement arises. The versatility of the chatbot developer can help in building software applications for diverse needs.

Knowledge of frameworks for developing chatbots:

The chatbot developer should be an expert in a variety of chatbot-related programming frameworks and platforms, including Wit.ai, Dialogflow, Microsoft Azure Bot Framework, IBM Watson, and ChatterBot, among others. To scale up your application in the future without any problems, you must find a chatbot developer who is skilled with a variety of frameworks and platforms.

Knowledge of cutting-edge technology:

The chatbot developer should be knowledgeable and skilled in a variety of cutting-edge, modern technologies, including artificial intelligence, natural language processing, and machine learning. This is one of the essential qualifications for a skilled chatbot developer, and a strong command of these technologies can advance the chatbot app development framework and related apps.

The obligations of chatbot creators:

It is crucial for hiring managers or recruiters to be aware of the responsibilities and role of the chatbot developers they intend to work with. You can find the ideal chatbot developers who can propel your company to greater heights by looking at how the function fits with the needs of the organization.

The developers of chatbots are in charge of creating unique chatbots that can conduct real-time conversations through the chat interface and are based on business requirements. Natural language processing, or NLP, is used to train chatbot systems to comprehend complex conversations so that they can accurately analyze the conversation's precise context.

The developers of chatbots are in charge of creating a complete chatbot application and utilizing data structures to add functions as and when necessary.

Additionally, versatile chatbot programs that can effectively communicate across a range of platforms and channels, including social networking websites and other applications, are planned to be developed by the developers. 

The creation of chatbots that can store significant data and use that data to take useful actions is another expectation of chatbot developers.

The chatbot developers are expected to carry out regular improvements to strengthen and improve the chatbot's capabilities by shifting business needs.

Developers of chatbots are also obliged to troubleshoot and fix any errors that could occasionally arise in chatbot operations.

The chatbot developers are in charge of monitoring the performance of the program, coming up with proposals for enhancements, and outlining the procedures necessary for the application's general improvement.

Rundown

Chatbot development company in the USA is meant to develop complete and AI-specialised chatbot development for your business. At Kodehash, we provide a one-stop solution of chatbot services at economical prices.

[preemploymenttest]

How to Hire a Software Developer

Hiring a software developer is no easy task. There are thousands of talented developers out there looking for jobs. How do you choose from them? Software development has become an integral part of our lives. From mobile apps to web applications, almost every aspect of our daily life involves some sort of software. The demand for skilled software engineers is growing at a rapid pace. Learn more: https://blog.hirenest.com/a-guide-on-how-to-hire-a-software-developer/

It takes time and effort to hire a good software engineer. If you don’t get it wrong, hiring a great developer can be rewarding. In order to ensure you hire the right person, follow these steps.

Step 1: Understand what skills and traits you want in a candidate. This will help you narrow down your search and focus on those candidates who match your requirements.

Step 2: Find a job board where you can post your job ad. Posting a job ad on a job board allows potential applicants to find your job opening.

A career in software engineering requires a bachelor's degree in computer science or information systems. Most employers prefer candidates with experience in programming languages like Java, C#, Python, Ruby, PHP, JavaScript, etc.

What is a Software Developer?

A software developer creates applications using computer languages like Java, C#, Python, PHP, etc. They work closely with business analysts, project managers, database administrators, and others to develop solutions that solve problems. You can find out more in our article: https://blog.hirenest.com/a-guide-on-how-to-hire-a-software-developer/

The job outlook for software developers is expected to grow by 20% between 2014 and 2024. This growth is due to increased demand from companies looking to innovate new products and services. Companies are increasingly turning to mobile apps and cloud computing to improve productivity and increase customer satisfaction.

What are the types of software developers?

The most common type of developer is the front end developer who creates user interfaces (UIs) and web pages. A back end developer writes code behind those UIs and web pages. They may write server side scripts or they may work directly with databases.

Front end development requires skills like HTML5, CSS3, JavaScript, and jQuery. Back end development requires skills like PHP, Python, Ruby, Java, C#, and SQL.

Software engineers build applications using programming languages. Some of the most popular programming languages include:

Javascript, Python, Java, C++, C#, Objective-C, Swift, Go, Perl, PHP, Ruby, Haskell, Scala, Clojure, F#, Erlang, Lisp, Prolog, Visual Basic.NET, Delphi, Pascal, Ada, COBOL, Fortran, Assembly Language, BASIC, Cobol, PL/1, Tcl, VHDL, Batch Scripting, Shell Scripting, Bash, and many others.

In addition to being able to program in one language, it's important to know at least two different ones so you can switch between them easily. This will help you become familiar with new technologies and keep yourself from getting stuck in a rut.

Why Hire Top Developers?

The best developers will not only understand what you want but they will know how to build it. They will have experience working with different technologies and languages, and will be able to quickly adapt to new challenges.

The first step is to find out if any of your current team members are capable of building this feature. If so, great! But if not, then you should start looking outside of your company. There are many freelance web development agencies who specialize in custom software development. These companies typically offer hourly rates and charge by project. Some of them may even work on retainer contracts where they provide ongoing maintenance services.

Why hiring a good developer is challenging?

The most common reasons why developers fail at building software are lack of experience, poor communication skills, and not having enough resources.

I am sure you know what it means to hire a developer but still, here we will discuss some points which may help you to find the best one.

There are many ways to develop software. It depends upon the type of project and requirements. In this article, we will discuss three different approaches to build software. They are Agile, Waterfall and Spiral Development.

Software development life cycle (SDLC) is the process of developing a product from its inception through delivery. SDLC consists of four phases: Requirements Gathering, Analysis & Design, Implementation and Testing. Each phase has its own set of activities and deliverables. These activities are performed by various groups within the company like Product Owner, Developers, Testers etc.

A software development team usually comprises of several people who work together to complete a particular task. This team includes a Project Manager, Team Lead, Scrum Master, Programmer, QA Analyst, UI Designer, UX Designer, Business Analyst, Customer Support Engineer, Technical Writer, Content Developer, and so on. 

Conclusion

The first thing to consider when hiring a software developer is whether he or she has experience with your industry. If you're looking for someone to build a website, then you want someone who's familiar with web development. If you need help building mobile apps, look for someone who knows about app development.

A good programmer will not only know the basics of programming languages but also understand what makes them tick. They should be able to explain why certain code works the way it does, and they'll be able to tell you if something isn't working correctly. This means being able to read through code and figure out where things might go wrong.

The best programmers are those who are passionate about coding and enjoy solving problems. If you're looking for someone who's going to spend all day every day writing code, then this job probably isn't for you. But if you want someone who enjoys coming up with new ideas and solutions to complex challenges, then software development may be perfect for you. If you want to know more about A Guide on How to Hire a Software Developer, read this article: https://blog.hirenest.com/a-guide-on-how-to-hire-a-software-developer/

[hireasp]

Java Vs Asp.net Which One Is The Best Choice For Your Project?

When developing applications, the language you choose is a crucial factor in the site's performance. The choice of programming languages is based on many factors, like the technical proficiency of your team. Budget, the nature of your website's learning curve, and more. Failure to choose the correct programming language can have catastrophic consequences. It is leading to the loss of money and resources. This is not an easy job, and numerous programming languages make it difficult for the user.

Build your app with us!! With your needs and requirements. Hire asp.net developer from us.

 Why Should We Compare Them?

You may be thinking about why we are comparing the two languages of programming and framework. The reason is that Java is frequently referred to as a framework, too. It is compatible with Groovy, Scala, PHP, Ruby, Python, and many more.

Both frameworks can be used for the development of desktop or web-based applications. They're mainly used to build complex enterprise-level solutions. They are object-oriented, allowing modular code and identical syntax, with both being made up of C and C++.

Therefore, both Java and .NET are extensively used in software development, enterprise-level, extensive data. And enterprise-level applications. So, it is sensible to evaluate the different technologies to see which one is best suited to your needs. As a user or your preferences as developers.

 Java vs .Net : Core Differences

Work Environment

Java Enterprise Edition and web applications created within it can be used on any platform. While the software built by using .NET is only compatible with only the Windows environment.

The target audience

Though .NET is targeted towards Windows users, only some open-source solutions are accessible. In contrast, Java takes advantage of Java Virtual Machine (JVM). As we all know, JVM is based on the idea that software can run on any device and run under all operating systems.

Languages supported

Java and .NET support common programming languages, such as Python, Ruby, and PHP. Furthermore, if you recruit Java developers and utilize JavaScript, Clojure, Groovy. 

The default language is HTML0.

The J2EE or Java 2 Platform Enterprise Edition set Java as default for the languages. However, .NET is compatible with different languages. You can select C#, F#, VB.NET, and C++. This is thought of as a more accessible option to develop business applications. However, the skills needed to code are more diverse.

IDEA

.NET Applications have an IDE that is a default called a studio. In addition, Java has four IDEs named Eclipse, IntelliJ Idea, Oracle NetBeans, and Oracle JDeveloper.

Java Vs ASP.NET Which one is more suitable for businesses?

In computer programming, we are constantly debating about Java and .Net. And their potential benefits in creating complex, enterprise-level apps. While they share many similarities, there are some fundamental distinctions between them. How do you decide which one is best for you? This article will assist you in making the best choice. It is crucial to work with the most reliable asp.net development company. To be aware of the exact requirements you have.

What exactly is Java technology?

It was released in 1995 by Sun Microsystems 1995. Java is a programming language and a computing platform that is speedy, reliable, robust, secure. And reliable for all your development requirements. It's practically everywhere and is used everywhere, from gaming consoles, datacenters to supercomputers.

What is ASP.NET?

ASP.NET is a no-cost open-source, cross-platform development platform to create various apps. .NET allows multiple languages editors, libraries, and editors to develop applications. For the desktop, mobile, web games, and IoT.

 Java Advantages

Java is a portable programming language. It gives you the option to select the machine and operating system you'd like to create your site.

Since Java does not often call databases and rarely, object-relational support is more efficient.

Integration of Java applications to other operating systems is effortless. This is accomplished through the help of modern integration tools such as Jenkins and Travis CI. It is simple to move between Java platforms since it offers backward compatibility. The Java community is expanding and changing constantly, so it will likely receive a lot of support.

.NET Advantages

Its popularity .NET is that it permits ASP.NET programmers to code in multiple languages. This makes it a versatile platform and user-friendly.

In line with the company's requirements, the developer will be able to use the best features of every language. And design an innovative website created exclusively for your business.

The versatility of .NET is one of the reasons why developers and businesses all over the world. Love ASP.NET for traditional web development.

Microsoft offers a single environment that runs on the .NET platform.

The .NET platform is an unhindered horizontal scaling capability that allows users to access tools. 

Disadvantages of Java

Because Java is platform-independent, the risk of security breaches     is relatively high. 

It is a multi-platform one; the developed app may be slower than     other languages.

Disadvantages of ASP.NET

There is only limited support for object-relational for .NET since     support is available only for Entity Framework. 

Migration code within .NET can be more costly when compared with     other frameworks.

Managed code in .NET might be slower than native code.

Java vs .Net Which is Better?

JAVA

Java is an advanced class-based, object-oriented programming     system.

Java applications run across all Java virtual machines (JVM)     regardless of the architecture used by the computer.

Supports Multiple Operating Systems.

Java is a less efficient method of garbage collection contrasted     to. NET.

Java JDBC (Java DataBase Connectivity) is used to connect to the     database.

For Java, various 3rd-party IDEs (Integrated Development     Environment) are available.

It can be related to architecture.

ASP.NET

.NET is an open-source, cross-platform open-source software     framework that allows you to create software applications.

Launched by Microsoft

.NET requires CLR (Common Language Runtime) for execution means     during runtime.

It is only compatible with Windows Operating System.

.NET is a much more efficient way of garbage disposal when compared     to Java.

The .NET ADO (ActiveX Data Objects (ADO) is used to establish     connections to databases.

It is an industry-standard IDE (Integrated Development     Environment), i.e. Microsoft Visual Studio.

It can work with disconnected architecture.

Java vs .Net: Development at the Enterprise Level

Each Java and .NET are excellent tools that can assist you in reaching your objective of developing a website for an enterprise. Their roots are in C# as well as C++ and C. Both of these languages are oriented towards objects and are safe for type. Although they use different syntax, each Java and .NET try their best to achieve the same goal.

What's Your Pick?

In the case of Java and .NET, there is no right or wrong answer. Positive and negative points describe both. Both of them can assist you in creating robust and flexible enterprise applications. The choice between Java and .net will depend on your site's needs. And the resources for development available and also the users.

To succeed and expand in a highly competitive marketplace, you'll need both languages. A business will benefit from both, resulting in highly-performing websites and apps.

To make the most of the two languages. Only an expert will create a professional solution that will provide you with the finest solutions you're seeking.

Where To Use Java?

Java can be described as a universal-purpose programming language. This means it can be employed in a variety of branches:

Android applications

Enterprise applications for enterprises (Java is extensively used     by the government and, as a result, frequently associated with older code.     However, it's also utilized for modern applications such as Pinterest and     Spotify)

Web-based apps (Google Docs and Gmail)

Software (Eclipse, Jira)

embedded systems

Where To Use .NET?

websites and web applications

Client applications

Gaming

enterprise development

[hirekhan]

Hire Clojure developer from HireKhan.com alternative to Fiverr.com , Upwork.com , Toptal.com , guru.com , freelancer.com, linkedin.com, 99designs.com , PeoplePerHour.com , Truelancer.com , Outsourcely.com Hire Clojure developer on contract / permanent basis,HireKhan Manpower - A Global Online Platform Hiring from India / Malaysia, Ukraine, United States.

 Welcome to HireKhan Manpower A Global Online Platform for Resource Hiring Powered by Artificial Intelligence QUALITY MATTERS Now outsource your recruitment process or book contract resources online with HireKhan Hire candidates locally or from across the world HireKhan.com provides contract & permanent resources on offshore or onsite model. Hiring for corporate, SME Organizations & individuals worldwide Just make a few basic selections, pay the engagement fee online and fill up the Job Description. That’s all. Deal done

 Hirekhan.com resource allocation team will contact to synchronize with your requirements and get onto sourcing the best candidates for you While you sit back and relax At HireKhan we follow a comprehensive AI based hiring methodology along with an expert team of specialized recruiters HireKhan is the only DOT COM gateway to India and other outsourcing destinations like Philippines, Ukraine, Vietnam etc. for its highly efficient and cost effective availability of Talent Your search for quality professionals ends at HireKhan

[tariqk]

Thinking about Lisp, software development and collaboration.

So like I've been reading a lot of Paul Graham's On Lisp, and Doug Hoyte's Let Over Lambda, and it's been... interesting.

Cut to spare the timeline.

Like, I don't pretend that I understand these works completely, or that I have anything more than a semi-functional understanding of Lisp — most of my work on Lisps have been on Emacs Lisp, which is really showing it's age, and I've honestly never touched macros in any reasonable level, because honestly speaking macros have a frightening reputation. Thanks to Graham and Hoyte's walkthrough of some of the concepts, though, I think my understanding's a little better, though it can only be tested if I can implement stuff on Common Lisp, if that day ever comes.

What struck me about the commentary was that, well, how much both Hoyte and Graham are fans of the language, and how they often extol its virtues. To both of them, Lisp is something that transcends other languages, that allow programmers to do things that are closer to the problem domain than anything else that people have made. That, when you make a programming language approach the kind of power, extensibility and flexibility that Lisp does, surprise! You've made another flavor of Lisp.

This is a seriously grand claim, but I kept being bugged by one question:

If Lisp Was So Good, Why Isn't It Used More Often?

Like, seriously, I kept reading these claims, and to some degree I could see them backing these claims with examples... and yet if you look at Common Lisp and Scheme projects on the Internet... they're like... scattered and fragmented. You can code, and most importantly, an overwhelming number of people do, from the beginning to the end, full-stack web applications in JavaScript. Lua gets used in everything from window managers to video games customization to desktop widgets. Python's still prevalent in web development to data sciences, and yes, some video games are customized in Python. Like, Ruby was everywhere for a while before it receded.

Like the only exceptions to this are, I guess, Emacs Lisp, which basically sticks with Emacs, and Clojure, which is tied to the JVM, and ClojureScript, which outputs JavaScript. Note how reliant they are on other software and frameworks.

The Answers I've Seen So Far

So, what gives? Like, I've been looking around, and I've seen basically two answers:

Lisp Isn't Popular Because People Are Stupid

No, seriously. This is the argument. Paul Graham engages in it:

People frightened by Lisp make up other reasons for not using it. The standard excuse, back when C was the default language, was that Lisp was too slow. Now that Lisp dialects are among the faster languages available, that excuse has gone away. Now the standard excuse is openly circular: that other languages are more popular.

(Beware of such reasoning. It gets you Windows.)

Popularity is always self-perpetuating, but it's especially so in programming languages. More libraries get written for popular languages, which makes them still more popular. Programs often have to work with existing programs, and this is easier if they're written in the same language, so languages spread from program to program like a virus. And managers prefer popular languages, because they give them more leverage over developers, who can more easily be replaced.

Hoyt engages in this, as well:

Macros have, not by accident, almost as much history as lisp itself, being invented in 1963 by Timothy Hart[MACRO-DEFINITIONS]. However, macros are still not used to the fullest possible extent by most lisp programmers and are not used at all by all other programmers. This has always been a conundrum for advanced lispers. Since macros are so great, why doesn't everybody use them all the time? While it's true that the smartest, most determined programmers always end up at lisp macros, few start their programming careers there. Understanding why macros are so great requires understanding what lisp has that other languages don't. It requires an understanding of other, less powerful languages. Sadly, most programmers lose the will to learn after they have mastered a few other languages and never make it close to understanding what a macro is or how to take advantage of one. But the top percentile of programmers in any language are always forced to learn some sort of way to write programs that write programs: macros. Because it is the best language for writing macros, the smartest and most determined and most curious programmers always end up at lisp.

I mean, the argument is pretty clear: because Lisp is so powerful, and that it takes so much study and effort to work at it, that only top-tier programmers are the only ones who understand Lisp. Implied, however, is the assumption that if you don't get Lisp, well, you're not a top-tier programmer, and you Just Don't Get It.

Which gets to the second explanation of why Lisp isn't popular:

Lisp Users Are Assholes

I mean, the above quotes are a sampling, and, honestly, a mild one, of the perceived attitudes of Lisp aficianados to the outside world. And it doesn't help that Hoyt then proceeds to call other non-Lisp Languages “Blub”, which, despite his many attempts to soften the blow, just makes him sound like an asshole. Like, you could have said “other languages”, dude. Sure it's less efficient, but you're dealing with people, not machines.

Like, Mark Tarver has an essay about the assholishness of Lisp users, which I don't recommend you read, because CONTENT WARNING ableism1. Maybe if you wanna take a look at commentary on that, you can go for Rudolf Winestock's The Lisp Curse, which is a little better, I guess?

Lisp is so powerful, that it encourages individual independence to the point of bloody-mindedness. This independence has produced stunningly good innovation as in the Lisp Machine days. This same independence also hampers efforts to revive the “Lisp all the way down” systems of old; no “Lisp OS” project has gathered critical mass since the demise of Symbolics and LMI.

[...]

Why [doesn't the Lisp community] make a free development system that calls to mind some of the lost glories of the LispM, even if they can't reproduce another LispM?

The reason why this doesn't happen is because of the Lisp Curse. Large numbers of Lisp hackers would have to cooperate with each other. Look more closely: Large numbers of the kind of people who become Lisp hackers would have to cooperate with each other.

The argument is, commercially, if you're a brilliant asshole, no one wants you. While your brilliance would be an asset for a while, what really makes organizations and enterprises scale isn't the fact that they hire brilliant people, but that they hire and use people brilliantly, in ways that are robust and don't rely on having the Right Kind of People on board. It's also why computer security is such a fucking thing to get right, because most of the solutions seem to be... hire the best in the industry and go with that? Which works great until your Chief Security Officer gets run over by a bus a better offer from the competition. Then what?

I mean, yes, capitalist models rely on you having a development workforce that is fungible, because it is cheaper in the long run, but it also reduces risk, even if reducing labor costs aren't a thing for you. It's also more democratic that way, because, yes, you need it to be accessible and approachable to the people who are affected by your code. And it needs to be reproducible, because if not, what if it's scientific work and we need to verify it?

But, even then, this diagnosis — that, charitably, the expressiveness of Lisp attracts brilliant assholes who can't even be convinced to work with one another rankles, because it fundamentally means that there's no solution. The language is too good for normies, and only assholes will use it, ∴ that's the end. Nothing more can be said.

I wonder if there's more to it. And I suspect there might be.

The Social Models Around Lisp Might Actually Be Toxic

Notice the commonality around the four people I've quoted above?

Yup.

They're all white dudes.

I'm not saying that the Lisp community is so toxic because the loudest voices within Lisp are all white men. I'm saying that the fundamental assumptions that these white men have about what is good might actually be a reason why Lisp's community might be so toxic.

There's a difference. Bear with me.

Graham actually talks about the process of developing software in Lisp — the bottom-up approach — but he talks about it in a way that assumes that development occurs with a single person, and that the final vision of the problem space is the insight of one person, or a small group of people with a common enough vision: sort of a Cathedral-style system. Does it have to be?

Why can't bottom-up development occur in a collaborative, cooperative system? Sure, Lisp “doesn't have syntax” (which always weirded me out — it does have syntax, just one that's “invisible” and “self-evident” to a certain class of mind). One that eschews the models that we're used to in capitalist and hegemonic systems. If Lisp is one of the purest forms of mathematical expression, what Hoyt refers to as a “U-Language”, shouldn't it be universally accessible and open to critique?

Maybe the reason why Lisp doesn't work is because the social models around Lisp — one that erases and diminishes the contributions and the lives of people who aren't white men of a certain analytical mindset — make it fail. Maybe whiteness — the social construct, one that lionizes individual brilliance of a specific kind, emphasizes competition over collaboration, pretends that there is an Objective™ Truth over the experiences of others, and considers all emotions other than violent, abusive ones weakness — is the reason why Lisp fails, despite its expressiveness and power.

Maybe the way to do it is to change the way people learn Lisp, and work with Lisp, and collaborate with Lisp, rather than the model we have today.

Could something like that, a system that allows easy, safe collaboration, and organisations that deliberately go for minority and disadvantaged groups, be something that could kick Lisp out of its doldrums?

He calls these people “brilliant bipolar minds”, because, of course. Just because you can diagnose the problem doesn't mean that you don't have the problem as well. ↩︎

[sacha-oleksandr]

Today, instead of doing a random prompt, I have an announcement and a happy little story!

Earlier in 2020, about the same time that we went into lockdown, my department at work was restructured. Previously, I was under the Final Documents Department, and we were our own thing parallel to the Shipping Department. However, the company hired a new manager for both departments and put them both under the Shipping umbrella (we shall call him Z). I was carved out as my own department and brought someone over from Final Docs with whom I worked well and who would become my ops assistant.

I became an actual manager with one employee. I delegated a few tasks to her, and we were in contact every day (both of us are still working from home), so it wasn’t like managing a team. Thankfully. Being a manager has reinforced my aversion to being responsible for another living being in any capacity, let me tell you. But we have been a pillar of efficiency and despite some technical difficulties a few times we have always managed to get everything done. (Okay, there are a few things dropped in our laps that we never got around to—but a lot of balls were dropped in the juggling of these tasks, and none landed in our court.)

When I first met Z, we had a video call where we introduced ourselves and spoke some about his philosophies on management and I explained what MERS is and what we do on my team. I mentioned to him that I was learning data science on my own time, especially since I was obsessively completing DataCamp courses while in quarantine, and he told me he knew the data scientist at our company who he was happy to connect me with. (Yes, there’s only one data scientist. We’ll call him A.)

A got me all kinds of permissions “under the table,” like access to the database that the software we use for the main company gets its information from and the ability to download programs and such things onto my computer. I got set up with Jupyter Notebooks and he walked me through some basic things I was having trouble figuring out. Once I got comfortable experimenting and building things on my own, I built a handful of report generators and transformers in Python that I could run on my computer, which takes a bunch of manual organization and review out of my daily routine (which is huge, because I’m handling daily reports and responsibilities for two of the three companies—my ops assistant does the dailies for the third). A helped me troubleshoot my code and marveled at what I could do on my own.

Fast forward to two or three weeks ago. A calls me and tells me he’s been talking with his boss about me, and for a few weeks they’d been discussing bringing me onto the new team of which A has recently become team lead, the Strategy and Innovation Group. He offered me a position as a junior software developer on his team and told me my first project would be to finish automating the crap out of my current responsibilities.

I had a call with Z and my ops assistant this morning to finalize the details, one of which is that she was offered a team lead position in the Final Documents Department! It’s extremely gratifying to know that the tools and methods I’ve taught her are actually contributing to her forward momentum and success.

The announcement, then, obviously, is that I accepted the position as Junior Software Developer in the Strategy & Innovation Group. I’m officially a tech person lol. And I have to learn a new programming language (Clojure) which is exciting and terrifying at the same time. The whole thing is, honestly. I have been the MERS Operations Manager since 2015 and frankly all my dreams for it are coming true: It’s being moved to a technical position, it’s being highly automated, and I get to be the one to make it happen.

Yay me! Sorry everyone, but 2020 is totally my year.

[holyjak]

On the other hand, I seldom had any problems turning my fresh college graduates new hires into competent Clojure programmers within less than a month.

-- How much can a Clojure developer do alone? https://yyhh.org/blog/2021/03/how-much-can-a-clojure-developer-do-alone

[nsfmc]

A checklist for computer science undergrads

influenced by john regehr's 'basic toolbox' post about this topic, i thought i would throw my hat into the ring given that my experiences have been different than john's and seem to be at odds with what i have observed from working with many competent developers.

As i was leaving grad school, a friend of mine suggested to me that a winning strategy in Industrial Design had been to pick some medium that you worked well in and focus on doing all your work with that. The rationale here was that starting anew each project with a new medium invariably impacted the execution of the final deliverable distracting your prof/critic/peers from the high-level feedback you actually wanted on your work, creative vision, etc.

The advice there is to focus less on the tool and more on using a tool efficiently to communicate your ideas. In most cases it does not matter what the tool is as long as you can deploy it to solve problems in your domain.

Much of the tooling that exists in CS is directed at very specific users: working programmers. using these tools correctly as an undergrad is aspirational, but often their execution is distorted in academic contexts.

Every lab or workplace should expect to bootstrap new hires on internal tooling/workflows and almost none of them should assume prior knowledge. Depending on the aims, the only hard requirement should be ability to program in a language or framework similar to the one being used.

Core skills

A single programming language

You do not need to be ultimately proficient in every language, you just need to be able to sketch out and implement a solution to most problems you encounter in one language you enjoy working in. Which language you pick does not matter. If you are in john's classes, however, you should probably ensure that you know two languages: a compiled/systems-ey one (rust, go, c, java, swift, clojure, etc) and a scripting language (python, ruby, javascript, clojurescript, elm, mathematica, anything goes here as long as it has a repl or runtime that you can use to hammer out solutions to problems).

If you're not one of john's students, typically the scripting language will suffice (although it is generally rare to finish a cs program being exposed to only one language).

s/Text Editor/Touch Typing/i

The advice to be familiar with a text editor is largely a request from others who expect you to competently pair-program with them at their pace. The point of knowing an editor is much the same as knowing at least one language passably: it should not be something that gets in your way.

More essential than being comfortable with a specific editor (it honestly does not matter which one as long as you like using it and you are productive with it) is being comfortable touch typing. In the event that slack or other IM platforms have not made you a better touch typist, it is well worth investing time if only so that the act of writing anything is no longer a major time hinderance.

At some point, you may find yourself bored or in need of procrastination and decide you want to customize your editor: that is a perfect time to try something like sublime or atom or vi or emacs.

rough shell experience

you should be able to navigate around a filesystem, make directories, read directory listings and read the cli help documentation for most commands.

you absolutely do not need to know the details of your shell's preferences around glob expansion or how to write legible shell scripts. you can learn that, but after a certain point, all the obscure functionality ends up beng more "dev-ops" style knowledge that rarely pays any dividends except when developing commercial developer-facing internal tooling.

incidentally, getting students past the hurdle of commandline BS is almost certainly a job of an advisor (or postdoc). Ignoring it helps nobody and if a research project's documentation (q.v. below) is poor or nonexistent, the PI only has themselves to blame for this ongoing time commitment.

reading documentation

this is probably the weakest skill i have seen from folks coming out of undergrad. nobody expects you to know all of a language, all of its quirks, etc etc. what you are expected to know is how to find the answer to any reasonable question around your language or toolchain of choice.

A useful skill: you should be able to, given a stylized block of shell commands, paste those into your terminal one-by-one in order to bootstrap some project i.e. ./configure && make && make test. nobody should expect that you understand autoconf unless your research project is specifically devoted to it in some obscure way (i'm sorry if this is the case).

Specifically, you do not need to know how to parse an excel-formatted csv, but you should know where to look (or be able to find a solution) in order to do that in a reasonable amount of time. You do not need to know what an ideal runtime serialization format is for your language, you only need to call back on the terms you learned in your cs classes: marshalling, serialization, persistence, writing data, etc. although it can be useful at the extremes, be skeptical of the amount and quality of programming language trivia you know offhand.

writing documentation

no, this is not technical writing. this simply means you should be able to write a plain text file for each project that outlines

how to build some program

what its implicit dependencies are

what its arguments are

what the exposed/public api is

aside from being useful to others, in roughly six weeks or half a semester, this will invariably be of use to future-you as well.

a good acid test here is pointing a friend to the project and asking if they can build it and understand how they might use it. at some point you will embed this knowledge into a Makefile, shell script, or some other dsl, but until then it is infinitely more useful to write down the steps.

html

unless this is your job (or you intend it to be) you only need to know how to make an academic-level webpage which requires only the most basic knowledge of semantic html: h1, h2, ul/ol li, p, a, img, pre, strong, em (optionally hr, dl dd & dt). avoid css. if anyone gives you shit, you can invoke "Default Systems" giving you a perfectly valid excuse to stop devoting any more attention to design after you have mastered those tags.

reproducing errors

it is unclear when you are an undergrad or novice if you have encountered a truly exceptional case or if you simply have no idea what you're doing. Make a habit of reproducing and then writing down steps to reproduce edge cases you encounter and share them with people you ask for help from.

above and beyond, if you can identify the specific step (or code or whatever) that you invoke that (seemingly) causes the error, you will have an easier time teasing apart the nature of bug as you are telling someone else about it.

the most basic of data visualization skills

all this means is that nobody is actually good at doing this and everyone thinks that two hours peeking at ggplot2 has made them wizards at communicating the complexity of some dataset or results. it hasn't.

in many cases it suffices to be able to graph something from mathematica, R, d3, mathplotlib, or google sheets / excel. again, nobody cares how you do it as long as you do it and it doesn't take you all day. if your lab or workplace has some in-house style for doing this, they will need to train you how to do that anyway.

nonlinear spider-sense

the single reason "big o" notation is taught in school is so that at some point you can look at a performance regression and say "ha, that almost looks like a parab—o.m.g." the ability to recognize code or performance that appears nonlinear (or pathologically exponential) is probably one of the core things that i think undergrads should try to hone because during almost no other time will you be asked repeatedly, and at length, to explain the space/time complexity of arbitrary blocks of code.

computers are fast enough that you can usually be blasé about performance but eventually you'll start looking. being able to recognize something that is accidentally quadratic is often the most practical day-to-day application of cs theory—hone this spider sense.

Nice to haves

Version Control

there is a large chasm between "git for one" and "using git as a team" and that harsh valley is almost certainly due to the large amount of human communication and coordination required to work on a project as a team. Most people stress learning git, but this is largely useless advice because most of git or hg's corner cases and weirdness only come up when you're trying to integrate your work successfully among your teammates. It is good advice to perhaps become vaguely competent using git or mercurial or rcs, that experience will almost certainly pale in comparison to the massive flail when you are trying to set up multiple worktrees to create integration branches that contain the contents of multiple prs (each likely with their own rebase/merge/squash quirks).

to that end, you should learn to, say, create a commit and push your work, but everything else beyond that is almost certainly guaranteed to be complicated by whatever your team's workflow is (github prs, phabricator, gerrit, etc). i have rarely met people outside of professional or open source contexts that are capable of producing sensible chained commits or sane pull requests, it is simply not a skill that is required outside of contributing to open source or working on a commercial application. When people ask for git experience they secretly crave this flavor of professionalism that it took months to acquire at each of their prior jobs or internships.

A Presentation Tool

the baseline here is very low, you only need to be able to make a presentation and in all likelihood if you are still an undergrad, you easily have ten-plus years of doing this already. worry about fonts/design/transitions/etc once your content is solid.

most people produce terrible presentations making the needed baseline here quite low—it is more important that you know how to practice giving a presentation than it is to actually create the slides for it.

debugger knowledge

i have met many successful professional working programmers that have little to no idea how their language's debugging tools work. if you are a gdb wizard this sounds shocking on its face but lots of developers make do just fine without them. This is not to say that you should be willfully ignorant of debuggers or eschew them (especially if this is part of your curriculum), but nobody should look down on you if you learn (or are taught this) On The Job.

many of these tools are technically robust but have a ui only moderately less hostile than an opaque box of loose razorblades and chocolates. much like git, most developers internalize some form of stockholm affection for these tools despite their poor design, nonexistent editor integration, and often incomplete terminal support.

you should understand roughly what a debugger is and what it can (and can't) do, but it's almost certain that you won't need to have mastered debugger internals straight out of college.

build systems

this is honestly a "top of maslow" need. This is great knowledge if you are planning to distribute code or need it to build dependably/reliably on others' computers, it is absolutely inessential for an undergrad to understand to do this level of orchestration except as documentation for others to evaluate that your project actually builds etc etc. if your advisor or boss asks you to learn something like make or whatever, then by all means.

You should know what a make tool is for and when it is necessary, but you should not expect that to apply to the lion's share of work you do in school.

working for a period of time before asking for help

although this should be a core skill many adults are incapable of doing this effectively. there is a tradeoff between "i'm learning" and "i'm being unproductive." In an academic lab, arguably much of your experience will appear to be some quantum state that simultaneously inhabits both extremes but your goal should be attempting to independently arrive at a solution and after some time cut-off (which you should negotiate with your advisor/postdoc/pi/whatever) you should say "i tried $A, $B, and $C to accomplish $GOAL and was unable to make any progress because $ERR_A, $ERR_B, and $ERR_C."

even the act of noting down "what i am trying to accomplish, how i tried, what went wrong" may in itself lead you to a correct solution, but without having done that due dilligence and outlined those aspects, it will be difficult to receive good feedback from somebody that is trying to help you.

unit/integrated/etc testing

if you find that something like TDD is useful for you as a productivity or refactoring tool, keep doing that! most working software people cannot even agree on what the point of testing is, so it feels unfair to burden undergrads with this. in a professional context, you will be in a codebase with some established testing norms, you need only mimic those until you have determined what works for you.

there are lots of sane and sensible resources for writing tests or thinking about tests. understand that everyone does testing slightly differently so your best bet will be to figure out how testing plays a part wherever you go. in most cases, that codebase will have a specific incantation to invoke tests, your best bet is to ask how they do things there are just go from there if the setup is not obvious.

understanding scope

most academic projects are poorly managed because they have inconsistent pressure to be profitable beyond whatever funding inspired them. simultaneously, many academic advisors are not trained well to manage or lead a team (remember, most were hired to write grants and produce research papers (or possibly to teach)). management is something an advisor is literally picking up "on the job".

If you are unsure what exactly you are supposed to do, you should clarify as soon as possible what deliverable is expected and when it is due. This seems obvious, but because communication is complicated you may end up assuming you need to, for instance, resolve outstanding cli argument parsing bugs rather than only needing to add support for a new one. Understanding the scope of a project you've been assigned prevents you from doing redundant work or opening prs that will never get merged.

language idioms

If you are cozy with a programming language, the natural evolution here is to begin learning what idiomatic programming is like for it: what are common libraries, do people tend to program it functionally or imperatively, for or map?, what patterns are awkward or hard to read, what are common tools in its toolchain, how do people use it to write web services, how do people use it to avoid shell scripting, what are its peformance pathologies, etc. this is the extension to knowing how to read the documentation: it is developing intuition about the language to avoid doing counterproductive work in the future.

Many developers learn one language and become fluent in its quirks then proceed to apply those to every language they see later on. if you encounter this as a novice, it may appear that they are simply Better Programmers and not, instead, people who are speaking a pidgin-python with a heavy haskell accent.

To recap

It is something of a mistake to hope that a cs student will have the gradually developed and refined skills of a professional tradesperson. Graduating cs students often do not have strong professional software development experience (this is what internships are meant to accomplish) but are good at thinking about design/architecture. if, at the very minimum, as an undergrad you can churn out some ruby and have the runtime execute it, you're usually in great shape.

most cs programs do not train students to develop tightly crafted applications with industry-tested documentation/syntax/structure/workflows etc. bootcamps, however, do stress this sort of thing, which causes a confusing periodic wave of "college is dead, long live bootcamps."

when looking at job descriptions or other checklists, it's useful to try to gaze back at the abyss and ask "why was this listed here?"

John's research is compiler-focused, deals with undefined behavior, and often invokes llvm, c, and other "low level" toolchains. a strong undergrad cs student will be able to intern with john productively because the core of his research focus is mostly general to computer science: correctness, compiler behavior, etc. someone with deep knowledge of C, llvm, compiler design/internals, etc is almost certainly in a position to become one of his graduate students or postdocs. I think john's list is interesting, but i think it emphasizes details that are often foreign to developers at all skill levels.

finally this list is biased itself, so take it with a grain of salt: all my work experience is in design and frontend/backend web development and the skills listed here represent the qualities i've observed from successful interns and developers i have interviewed and worked with in the past ~ eight years. my experience is clearly n=1, but among the things i've noticed is that it's easy to get people to learn git, but it's hard to get somebody to internalize recursion, nonlinear growth, or canonical architecture patterns within the same time period. i'm not saying it's impossible, but if you're a cs student, this is 100% what the point of most cs programs is.

[weekinethereum]

September 19, 2017

Ethereum News and Links

Toshi (formerly known as Token) is now live on main net. As early technology, Ethereum needs to progress in scalability, privacy and usability.  Ethereum needs apps like Toshi, Status, Leth, imToken, etc to make Ethereum usable by non-nerds.  You can message me @EvanVanNess and make sure to rate Toshi’s Week In Ethereum app.

MicroRaiden:  "off-the-shelf micropayment solution."  Live on Kovan, main net "very soon."

Fizzy: Largest insurance company in the world copies Etherisc's flight delay insurance, currently live for flights between Paris and the US. (Oracle problems?)

Cosmos published Shanghai Accord - Ethereum Scaling Agreement, which is mostly Vitalik expressing support for Cosmos building things that make Ethereum more scalable by moving stuff to another chain through interoperability

Vitalik: "This is the real "ethereum scaling roadmap" - it's a combination of continued improvements to increase the scalability of the base chain, together with the ability for anyone to make their own system that hooks into ethereum that provides its own scalability as well as possibly other properties that the base chain does not."

Protocol

Alex Van de Sande explains what's in the Byzantium hard fork

Ropsten testnet successfully hardforked to Byzantium.  I've seen talk about whether people will keep the old chain alive -- but the old chain will be in ice age, so you'd actually have to hard fork the old chain in order to keep it alive.  Seems tough from a marketing standpoint.

Bug bounty doubled for issues relating to the upcoming Byzantium fork

Byzantium releases: Geth v1.7 and Parity v1.7.2 release

Token Contracts on Plasma or: a Tale about Local and Global Invariants

Diving into the EVM, pt 4: Deciphering a method call

Zero-knowledge proofs, Zcash, and Ethereum

ZCash's "groundbreaking performance improvements" for zk-SNARKs

Christian Reitwießner: testnet just verified a zcash transaction

Stuff for developers

Implementing the EVM in Clojure

Building a table of token holders using Quickbooks

How to read Ethereum contract storage

Maurelian: The use of revert(), assert(), and require() in Solidity, and the new REVERT opcode in the EVM

Ecosystem

Ethereum authenticated VPN service

Matrix & Riot for Crypto-Communities

How MetaCert is working to make Slack usable by crypto projects again

Orinoco: Understanding ERC-20 token contracts

China: it seems as if blockchain crackdown is more serious than expected. Exchanges are closing and perhaps exchange operators have been told to stay in China?

Explaining Raiden without using the bar tab analogy

Oraclize and Eidoo are semi-merging

ConsenSys is hosting the first global MBA Blockchain Venture Competition

Mike Goldin: Token Curated Registries

Vitalik: A Prehistory of the Ethereum Protocol

Project Announcements

Props Project by the YouNow team.  Video announcement. Whitepaper

EthRPS: play rock-paper-scissors for money

Leverj: futures exchange with margin, supported by ConsenSys

FansUnited: sports betting

GitToken: earn tokens for your pull requests

Ocean: Trent McConaghy's decentralized data marketplace protocol

Project Updates

Augur's Solidity migration is complete

The 0cean's "high performance funnel" order book

ICONOMI September AMA

More on Legacy's vision of transfering your memories and belongings after death

Secure & fair shuffling of the deck on Virtue Poker

The Brave browser now blocks backgroun coin mining scripts

Decentraland's first LAND sale

Decentraland community whitelist is ongoing

Interviews and Talks

Gavin speaks: Interview with Ethereum co-founder Gavin Wood

More Parity: Jutta Steiner on Governing the Future podcast

Q&A with Luis Cuende of Aragon

Status Q&A with Stani Kulechov from ETHLend

William Mougayar talk at ICO Summit

Brendan Eich podcast interview with Aaron Watson

Cofound.it's Daniel Zakrisson and David Szabo on trends at ICO Summit

Doug Petkanics from LivePeer is my guest for episode #2 for An Ethereum Podcast. We get deep into the magic of decentralized video.

San Fran Ethereum meetup: Jun from OMG, Vitalik, and Joseph Poon.  Also, Sergey Nazarov on ChainLink

Silicon Valley meetup: Vitalik Buterin, Balaji Srinivasan, Joseph Poon, and Dan Boneh

Naval interviews Vitalik at TechCrunch Disrupt.   Vitalik is optimistic we can scale to Visa-like levels in a few years.

Token Sales

Grid+: The P2P grid we want, and why we need a blockchain

Seems like Etherisc wins at every blockchain startup competition

Livepeer for beginners

This week in undisclosed celebrity ICO shilling: Jamie Foxx

Request Network token sale details.  Yellow paper.

General

Someone wrote comedic fiction about being the hacker of the Parity multi-sig wallet

People keep sharing this image of JPMorgan being one of the biggest buyers of Bitcoin after Jamie Dimon's fraud comments.  But most likely this is just JPMorgan's brokerage activity, not them trading their own account.

Trusted IoT Alliance: "set the standard for an open source blockchain protocol to support IoT"

EY rigged their coffee maker with a Raspberry Pi to accept payment using LETH

People widely shared a TechCrunch article due to headline of "SEC show support for ICOs" but it was just a weakly supported opinion piece

Dates of note

From Token Sale Calendar: (didn't have time for comprehensive update for the newsletter before I had to get on my flight, please click the link for an updated list of sales)

Upcoming token sale start dates:

September 21 – Digital Asset Power Play (Cofound.it Priority Pass presale: Sep 19)

September 21 – Opakeco

September 25 – EthLend

September 25 – Jibrel Network

September 28 – Doc.ai

September 29 – Snip

September 29 – Customizable Basic Income

September 29 – Assistive Reality

October 1 – Hirematch

October 1 – Etherparty (pre-sale ongoing)

October 2 – Rhea

October 2 – WandX

October 2 – Horizon State

October 3 – Enjin (ongoing pre-sale)

October 3 – Snov

October 10 – Swap

October 10 – Notary Platform

October 15 – Paypie

October 30 – Grid+

November 1 – Winding Tree

November 1 – ScriptDrop

Ongoing token sales:

Streamr

Privatix

MatchPay

Gimli

Databroker DAO

Circles

Relest

Wolk

Air Token

Spheris

Aeron (ongoing pre-sale)

Maecenas

Kin (must have already registered)

Bitjob

LookRev

Matryx

Atlant

Avalon

Payfair

HelloGold

REAL

Eventchain

Authoreon

Magos

PowerLedger

Vibehub

Paragon

Agor

Propy

Umbrella Coin

Want to be included?  If you are building your project on Ethereum, email weekinethereum @ gmail [period] com with 1) your URL, 2) sale date and 3) a brief but convincing description of how you are using Ethereum, preferably with a link to your Github repo.  Listings are free.  But please make sure to follow those instructions.  If you don’t follow the instructions, you likely won’t get a response.

WARNING: list may include or even likely includes scams and quasi-scams.  Do your own research and due diligence before putting value at risk.

[I aim for a relatively comprehensive list of Ethereum sales, but make no warranty as to even whether they are legit; as such, I thus likewise warrant nothing about whether any will produce a satisfactory return. I have passed the CFA exams, but this is not investment advice. If you're interested in what I do, you can find my somewhat out-of-date investing thesis and token sale appreciation strategies in previous newsletters.]

Every week I still get emails saying, "you joined ConsenSys?"  So this section stays.

If you emailed my Ticketleap email address in the last 30 days or so, then I likely didn't get it.  If you were waiting on a response from an email you sent there, I suggest you re-send to weekinethereum @ gmail [period] com.

I've joined ConsenSys.  Here's a logo to draw your eye in case you were going to skip over this section:

My charge from Joe Lubin is pretty similar to what Status has told me: keep telling the truth and covering the space as objectively as I can.

Permalink

I measure the success of each issue by how much it gets upvoted and shared. This is the link:  http://www.weekinethereum.com/post/165538198138/september-19-2017 Follow me on Twitter? @evan_van_ness

This newsletter is supported by Status.im and ConsenSys (have you seen that we're hiring?).  But in case you still want to send Ether or tokens:  0x96d4F0E75ae86e4c46cD8e9D4AE2F2309bD6Ec45

Sign up to receive the weekly email.

[vishers]

Video Roundup

Principles of Collaborative Automation - Jessica Kerr - YouTube

Jessica Kerr is amazing. I need to add her to my must watch list. This talk helped me to realize that I need to think about my automation as a partner that can communicate back to me just as easily as I can tell it what to do.

Java Futures, Early 2019 Edition - Brian Goetz - YouTube

Brian Goetz and the rest of the Java team are, as I say whenever I get the chance, an inspiration. I love watching him thoughtfully explore how to adopt the most powerful features from other more experimental technology into the bedrock of this platform.

Our Terraform Journey: The Good, The Bad, The Ugly - YouTube

I'm going to be leading an effort soon to do exactly this. We've been using Terraform for a long time but our usage is decidedly basic and that leads to it being decently hard to maintain and also hard to secure. This talk was helpful in thinking about how to do that.

These are directly related talks

Infrastructure as Code for Software Engineers - YouTube

Crawl, Walk, Run With Terraform - YouTube

Transforming the Management of Application Configurations and Secrets - YouTube

Seth Vargo Closing Keynote - YouTube

Listen to everything Seth Vargo says always. He thinks about development and operational responsibility in such a clear and helpful way. I like this talk because it thinks creatively about how to test (Hello Building Evolutionary Architectures and also advocates for technological constraints.

"Shaping our children's education in computing" by Simon Peyton Jones - YouTube

Similarly listen to everything Simon Peyton Jones says always. He has been applying himself to the problem of education for the past few years and this is an incredibly inspirational and thought provoking talk.

"Gradual typing of Ruby at Scale" by Dmytro Petrashko and Paul Tarjan - YouTube

So much of what I do is this kind of work. Making engineering safer, faster, and easier at the tooling level. I liked this talk especially because of the adoption strategy that they present.

"Data Driven UIs, Incrementally" by Yaron Minsky - YouTube

This talk is really well done and completely outside of my circle of competence which are usually some of my favorite and most fruitful talks to watch. What's presented essentially is how to have highly performant, extremely data-intensive UIs functionally.

"Hackett: a metaprogrammable Haskell" by Alexis King - YouTube

Another relatively left-field talk for me. I love the marriage of metaprogramming and type theory. I still want to explore a language with an actual robust type system.

"Justice For Sale" by Brittany Wald - YouTube

Mass incarceration is a problem. Brittany Wald wants to apply technology to eliminate the gaps between those who can afford justice and those who can't.

"Tree-sitter - a new parsing system for programming tools" by Max Brunsfeld - YouTube

All I want to know is when support for this is landing in Emacs. It's a really intriguing approach to parsing.

"A Tale of Two Asyncs: Open Source Language Design in Rust and Node.js" by Ashley Williams - YouTube

I love the concept of genealogical analysis since I think it fosters intellectual humility. The bold 'rationalism' of the enlightenment is a blight on the land. I'm also a sucker for software history dives.

"Contracts For Getting More Programs Less Wrong" by Rob Simmons - YouTube

I'm a big fan of contracts and they're something I wish I had time to explore more.

"Performance Matters" by Emery Berger - YouTube

This is really one of the better talks I've ever seen. What a presentation! It also, of course, brings to mind It Takes Awhile to Create Nothing by Ron Jeffries. Learn all about how layout can affect performance and how you can apply rigor to engineer around it. Also Coz seems quite neat.

Related:

"A Practical Look at Performance Theory" by Kavya Joshi - YouTube

"A Box of Chaos: The Generative Artist's Toolkit" by Benjamin Kovach - YouTube

Another from left field. Some of the art was quite beautiful and I love the idea of programmer as curator in this space (and possibly many other AI spaces).

Related:

"The Glitching Hour" by Amy Wibowo - YouTube

"Understanding Microservices with Distributed Tracing" by Lita Cho - YouTube

Upping our observability game is top of mind.

Related:

"Observability: Superpowers for Developers" by Christine Yen - YouTube

"Beyond traces: the insights in trace aggregates" by Daniela Miao - YouTube

"Freeing the software that runs our elections" by Roan Kattouw - YouTube

This talk made me think, as I often do, of whether I should be using my software engineering career to be doing something other than helping people with a lot of money take more money from people who have less money.

"Isolation without Containers" by Tyler McMullen - YouTube

This talk reminded me of a tweet by Jessie Frazelle about how a complex istio+knative feature can be accomplished in just a few lines of bash using standard linux tech. So much of 'progress' in tech is someone just ignoring or being ignorant of how something already works and going and making some framework or tool for it with all the bugs that have been fixed in the intervening 15 years since the feature that already did it was introduced.

"Moving from 1 to N regions: an open retrospective" by Andrew Bloomgarden - YouTube

This is literally my job right now. I need to take some more detailed notes about this one and apply them. I really appreciate the 'open retro' format of this talk.

"Git from the Ground Up" by Safia Abdalla - YouTube

Can anyone resist watching a talk on git internals?

"Building Senior Engineers" by Dalton Mitchell - YouTube

This talk really hit home. I have rarely seen mentorship done well and most companies I've worked for have prioritized hiring engineers that can just 'plug and play' (which never really works out anyway) rather than focusing on growing the engineers they need.

"Alda's dynamic relationship with Clojure" by Dave Yarwood - YouTube

Watching weather data become sound was so much fun.

"Safety in Chaos: Forming Realistic Failure Hypotheses" by Subbu Allamaraju - YouTube

Chaos Engineering is something that I want to get into asap.

"Uptime 15,364 days - The Computers of Voyager" by Aaron Cummings - YouTube

This talk was an incredible amount of fun. I want to be friends with the presenter. It immediately made me think of Russ Olsen's "To the Moon!" which I was lucky enough to see live.

"Correctness proofs of distributed systems with Isabelle" by Martin Kleppmann - YouTube

I want to be able to reach for correctness proofs for particularly important problems. I'm a pragmatist at heart and I think the number of things this is really important for are quite small but having the tool in my toolbox would be amazing. It immediately makes me think of Testing the Hard Stuff and Staying Sane by John Hughes.

"Better Integration Tests for Performance Monitoring" by Maude Lemaire - YouTube

I love the idea of testing in production. Performance regressions as integration tests is a really neat idea.

"Meander: Declarative Explorations at the Limits of FP" by Jimmy Miller - YouTube

Declarative programming is a recurring theme in my tech exploration, possibly because the Clojure community at large is pretty obsessed with it. Having just read through The Art of PostgreSQL I can say that believing that you can write a better algorithm is almost always hubris. Meander immediately made me think of specter although the speaker took pains to differentiate them.

It also reminded me of an old idea I had to use example data as the query interface.

Keynote: Collective Problem Solving: Music, Science, Software - Jessica Kerr - YouTube

This is my kind of talk. Jessica Kerr goes an a discipline melding tear to sell her new term for the way we develop software in partnership with each other and our automation.

Rust: A Language for the Next 40 Years - Carol Nichols - YouTube

I want to learn Rust at some point, just like I want to learn Go. I'm especially intrigued by Rust's governance model. I wonder how that will shake out over the years.