How To Make A Directory In Clojure

Each language has its own set of tools to learn, and ClojureScript is no different. In this book, we will focus on two very important tools - clj for general-purpose build tasks, and Figwheel for live reloading of code. We'll begin by looking at our new friend clj, the built-in command-line tool for managing dependencies and building code. Like JavaScript's npm, clj is a configuration-based dependency manger as well as a simple build tool. The reader who has some familiarity with building software projects should feel at home rather quickly, but do not worry if this is your first exposure to using a build process.

We will walk through the essentials in enough detail to get comfortable building ClojureScript applications. As it happens with most programming languages, you can use many techniques in order to copy a file. This example uses the simplest method for copying a file with a single function call. For reasons of simplicity, the input and output filenames are hard-coded in the project files and are assigned to two variables named input and output, respectively. After that, a call to clojure.java.io/copy creates a copy of the input file.

Profiles allows you to customize your project.clj setup for development, production, or the REPL. Profiles allow you to customize any aspect of your project.clj. You can bring in specific dependencies, include additional directories, and change compilation options, among other things. Our project.clj has only one profile, uberjar, which is used for compiling our production application. There is not a great comparison for "profiles" in Node.js. The fastest way to create a new project is to use lein new command, that accepts one required argument — name of the project.

A deps.edn file lets us specify script aliases that allow us to declare a shorthand for a number of commands or even run a Clojure file. You should be able to descend into the newly create directory clojure-examples. This would normally be used as an outline of a Clojure project. For the purposes of demonstrating Clojure source code in org-mode, this project is only used to allow Leiningen to deal with Java class paths and resolve dependencies.

In this case, it will download the Clojure core into your machine. If other dependencies are required, they should be added to the project.clj file. For the purposes of this demonstration, simply creating the project is sufficient to proceed.

Clojure's philosophy is based on Lisp, which means that Clojure code contains lots of parentheses. Additionally, Clojure is a functional and dynamically typed programming language that has support for concurrent programming, which means Clojure's functions have no side effects. As the implementation of Clojure is based on the Java Virtual Machine, Clojure data types are Java data types, which means that all Clojure values are in reality references to Java classes. Moreover, most Clojure data types are immutable, which means they can't be changed after they've been created. Finally, Clojure has an unusual way of checking for equality.

In order to find out whether two lists are the same, Clojure checks the actual values of the two lists. Most programming languages don't do that because it might be a slow process, especially when dealing with large lists. Nevertheless, Clojure avoids that risk by keeping a hash for each one of its objects and by comparing the hashes of two objects instead of actually visiting all their values.

This works as long as the objects are immutable, because if objects are mutable and one of the objects changes, its hash table won't be updated to reflect that change. The philosophy behind tools.build is that your project build is inherently a program - a series of instructions to create one or more project artifacts from your project source files. One detail that sometimes trips up newcomers to ClojureScript is the fact that we name directories in the project with underscores but we name namespaces with hyphens.

This is a convention borrowed from Clojure, which compiles namespaces into Java classes, naming the classes according to their file path. Since hyphens are not allowed in Java class names, they are not allowed in the file paths either. ClojureScript follows Clojure's lead and requires that hyphens in a namespace be converted to underscores in the filesystem path. It is a quirk, but it is one that is easy to live with once we are aware of it. When you launch Figwheel it not only starts a live building/reloading process but it also optionally launches a CLJS REPL into your running application. This REPL shares compilation information with the ClojureScript compiler, allowing the REPL to be aware of the code changes as well.

The REPL also has some special built-in control functions that allow you to control the auto-building process and execute various build tasks without having to stop and rerun figwheel.main. At this point, you should have all the tools you need to start organizing your projects. You now know that namespaces organize maps between symbols and vars, and that vars are references to Clojure objects . Def stores an object and updates the current namespace with a map between a symbol and a var that points to the object. When we invoke clj -m cljs.main ..., several things happen. First, any dependencies specified in deps.edn will be downloaded.

This download will only happen on the initial run, and the packages will be cached locally for subsequent runs. Second, the Java Virtual Machine will be started and the Clojure compiler loaded. Next, Clojure will load the code specified by the -m flag.

In our case, we specify cljs.main, which is the entrypoint for the ClojureScript compiler. This code is available to us because we added the package for the ClojureScript compiler (org.clojure/clojurescript) to deps.edn. The Clojure language comes with a command-line tool that can be used for compiling both Clojure and ClojureScript. While other build tools exist, the clj tool is the defacto option. It is a simple tool, but it is powerful enough to use even on a large project.

We will use it for managing dependencies, compiling, and testing our projects. Using a single tool for all of these concerns should come as a welcome change from the proliferation of tools in the JavaScript landscape. Before proceeding any farther, we should install Java and Clojure. Since instructions change slightly with each release, readers are encouraged to follow the most recent instructions at the official Clojure Getting Started Guide. One interesting feature of ClojureScript is that we do not need to install it manually - we only need to specify it as a dependency of our project.

Once Clojure is installed, we can create a new project. Once your directory structure is created, copy paste the code shown below to my-first-clojure-app/src/my_first_clojure_app/core.clj . This is the core file where the main code for running the Clojure app should be present. Clojure community encourages a high amount of abstraction, so you should be creating a lot of such libraries with a small amount of code in the core.clj file. Leiningen is extensible — if necessary, you can add your own commands.

To do this you need to create a project, in which exists leiningen.command_name namespace, containing implementation of your command as a function with name command_name. This function receives project's object as an argument. More detailed information on writing plugins you can find in following blog post. One of example of plugins for Leiningen is thelein-swank plugin, that implements support for Swank server — you can find it in Leiningen's repository with source code.

Let's build the "learn a language" program with Leiningen. We have a very basic project at make-a-clojure-baby/leiningen/lein-build. Under that the directory, the file src/learn_a_language/important_phrases.clj is the same as the one listed above. The index.html was created with a single div that we can load our application into, and it includes the JavaScript file that will load our application with its dependencies. Normally, you'd simply create the .dir-locals.el manually and edit it like any other Emacs Lisp code. If you, however, feel overwhelmed by its syntax you can simply do M-x add-dir-local-variable and you'll be able to select the major-mode, the variable and its value interactively.

One small problem with this approach is that the resulting.dir-local.el will be created in the current directory, which may be a problem depending on what you're trying to do. Users ofProjectile may leverage the project-aware projectile-edit-dir-locals command instead. Clojure-lsp will look for project specific settings in a file called .lsp/config.edn. It will search from your project root folder up the directory structure so you can have multiple projects share the same settings.

Till now you have been using lein repl to explore the intricacies of the Clojure code you have seen so far. In the real world, you make actual applications and then ship/release those applications. More often than not those applications will sit alongside some legacy Java applications that have already been built and are running on the JVM in production. So, in this section, you will learn how to create effective production code and ship it. This tutorial assumes that you have leiningen installed and running. Target-path is the directory where compiled files will be placed when you run lein uberjar to build your production application.

If you have used webpack before, this is similar to the output key instructing webpack where it should output your bundles. It first checks the clojure.lang.Compiler/LOADER dynamic var. From scouring the code it seems this is used to set the loader internally during a specific scope, but what this ultimately is used for I have no idea. It does give you a way to override the classloader that Clojure uses, by giving that var a root binding.

A key concept when working with Clojure is "the classpath", a concept which we inherit from Clojure's host language Java. It's a sequence of paths that Clojure checks when looking for a Clojure source file (.clj), a Java Class file (.class), or other resources. So it's a lookup path, conceptually similar to the PATH in your shell, or the "library path" in other dynamic languages.

Project's source code should be stored in src directory, tests — in test directory, and additional resources, used by project — in resources directory. The lib directory is used to store libraries, used by project — they are copied there with the lein depscommand. List of libraries is calculated using information about dependencies, declared in project. If you want to use library, that isn't stored in one of the Maven's repositories, then you can just copy this library into lib directory, and it will available to your project.

The Clojure namespace clojure.java.io contains useful functions to work with files. We can pass a java.io.File instance as arguments or use the same arguments that can be passed to the file function that is also in this namespace. The function will create all parent directories for the file. The return result is true if the directories are created (they didn't exist before) and false when the directories didn't have to be created . The entire Metabase application is compiled and assembled into a single .jar file which can run on any modern JVM. There is a script which will execute all steps in the process and output the final artifact for you.

You can pass the environment variable MB_EDITION before running the build script to choose the version that you want to build. If you don't provide a value, the default is oss which will build the Community Edition. You're missing nothing, you are correct in that the test function will be pure. What I was looking for is for an approach that would leave me with two functions in the "production code", one pure and another one isolating the side-effects.

I would only need to test the second one without the need for additional mocks. Your Procfile should declare what process types make your app run. It also uses profiles that are intended for development, which can let test libraries and test configuration sneak into production. It needs to be in src/pinheiro/main.clj from the project root. Once you declared in deps.edn that src is where your classpathstarts, we say that it's pinheiro/main.clj in your classpath. As for symbols, you've been using them this entire time without even realizing it.

For example, when you write (map inc ), both map and inc are symbols. Symbols are data types within Clojure, and I'll explain them thoroughly in the next chapter. If you want to just use the symbol itself, and not the thing it refers to, you have to quote it. Quoting any Clojure form tells Clojure not to evaluate it but to treat it as data. The next few examples show what happens when you quote a form.

--main invokes aClojure function, in this case cljs.main. The cljs.main function supports a variety of command line arguments to specify common tasks. We're using--compile to specify that we want to compile the hello-world.corenamespace. This is followed by --repl to say that we want a REPL to launch immediately when compilation completes. Directory and load them from there, to do so is really to make them part of your application's source code, which rather defeats the purpose. You may wish to load that kind of frequently changing resource in a known filesystem location and load from there instead, rather than using the classpath.

Since our application is called guestbook, this is the root namespace for the project. Let's take a look at all the namespaces that have been created for us. The first time you execute lein run, lein might automatically download some files that are required for building the project. Additionally, keep in mind that lein can do many more things than what I describe here.

The next most important lein commands arelein clean, which cleans up a Clojure project, and lein repl, which starts the Clojure console. But sometimes you need to call Clojure functions from Java. People usually use Clojure because they have huge applications written in Java. They probably want to extend that application and create the new feature in Clojure.

Clojure's many advantages of speed and crispness of code make it an ideal candidate to be integrated into your code base. I am assuming you will encounter the same situation making you want to create the new feature as a Clojure function and call the function in Java. Clojure provides the required classes to call the Clojure code in your Java app and then run it.

The Clojure code will run through an interpreter as a side effect in Java and then the results can be imported and analyzed. The app-routes function will take in a redis-component as an argument which it will then pass to its route handlers. Make a new file handlers.clj in your src/clojure_for_js_devs directory, and add the following code.

What Would 1000 Invested In Apple In 1997 Be Worth Today

Schwab completes acquisition of Wasmer, Schroeder & Company, LLC, a leading independent investment manager of fixed income separately managed accounts. Schwab acquires Motif's technology and intellectual property, including algorithms, patents and source code. The firm completed the asset acquisition of USAA's Investment Management Company and transitioned the underlying brokerage and managed portfolio accounts to Schwab. Schwab introduced Schwab Stock Slices™28, a new service that enables investors to own any of America's leading companies from the S&P 500 for as little as $5 each, even if their shares cost more.

Other investment professionals often face far greater performance pressure. Consider mutual fund managers, whose fund performance is reported daily, whose investors can withdraw money at any time, and who are often replaced for underperformance. VC performance is ultimately judged at the end of a fund's 10-year life, so venture capitalists are free from the level of accountability that's common in other investment realms. They take on less personal risk than angel investors or crowdfunders, who use their own capital.

And all investors take fewer risks than most entrepreneurs, who put much of their net worth and all of their earning capacity into their start-ups. VCs are often portrayed as risk takers who back bold new ideas. True, they take a lot of risk with their investors' capital—but very little with their own. In most VC funds the partners' own money accounts for just 1% of the total. The industry's revenue model, long investment cycle, and lack of visible performance data make VCs less accountable for their performance than most other professional investors.

If a VC firm invests in your start-up, it will be rooting for you to succeed. But it will probably do just fine financially even if you fail. I am not a mathematician but I know a little about investing. The larger the base, the more the investment balloons exponentially.

The article uses a $1,000 investment in Apple stock the day "Forrest Gump" was released as now being worth $610,000.49 based on a share price of $146.40 for Apple. So, a $3,500 investment base means a 3 ½ times more exponential growth as shares over the decades, split. That exponential growth is the only answer that I see for the differential over the years in the hypothetical $1,000 investment and my daughter's $3,500 investment. Like Microsoft, information technology firm Oracle went public in 1986 and has offered investors similar bumper returns over the years. In 1987, $1,000 would have bought 50 shares, which would have turned into 16,200 shares worth $646,542 (£442k) by 2016, even without the dividends reinvested. Small-, mid- and large-cap stocks are ways to categorize market capitalization, which is the total value of all the shares of a company's stock.

Very large companies like Apple and Alphabet are considered large-cap stocks with market capitalizations starting at $10 billion. Stocks from relatively smaller companies are considered mid-cap or small-cap depending on how much all of the stocks they are issued are worth. Market capitalization for mid-cap stocks tends to be between $2 billion and $10 billion and for small-cap stocks between $300 million and $2 billion. As stock prices go up and down over time, market capitalization ranges and whether a stock is considered small-, mid- or large-cap changes over time as well. Entrepreneurs have more choices for financing their companies, shifting the historical balance of power that has too long tilted too far toward VCs. Entrepreneurs will enjoy a different view as they move from the backseat into the driver's seat in negotiating with VCs.

What Would 10 000 Invested In Apple In 1997 Be Worth Today An emerging group of "VC 2.0" firms are going back to raising small funds and focusing on generating great returns rather than large fees. And the industry's persistent underperformance is finally causing institutional investors to think twice before investing in venture capital. As a result, VCs will continue to play a significant, but most likely smaller, role in channeling capital to disruptive start-ups. Nevertheless, this business model seems to pay out, and investors are well aware of that. The company's market capitalization has increased multiple times since 2009.

If you had invested $1000 dollars in Netflix stock 10 years ago, today you would walk away with more than $49,000. Several biotech companies have experienced rapid growth in the 21st century, offering investors enviable returns. Back in 2000, $1,000 would buy you in 62.5 shares in Illumina, 'the Google of genetic testing', at its IPO. Today, those 62.5 shares have multiplied to 125 worth $17,935 (£12.3k), even without dividends reinvested.

British property investment firm Helical Bar has rewarded early investors with excellent returns. So $1,000 invested in 1985 would have grown to $723,000 (£494,492) by 2016. Across the pond, you would have wanted to buy shares in a firm called Balchem, the best performer on the US stock market over the last 30 years. Its stock price has increased by 107,099% since the end of 1985.

It's not hard to figure out why M&T Bank stock is one of Warren Buffet's favorites. Back in 1983, 1,300 shares were priced at $1,000 (£2,400/£1.6k in today's money). Thanks to several stock splits, those 1,300 shares would have turned in 26,000 worth $3.1 million (£2.1m), even without the dividends reinvested. An investor who purchased $1,000-worth of stock in Malaysia's Public Bank Berhad when it was listed in 1967 would now own 135,400 shares worth $336,000 (£230k), without dividends. On Thursday, Apple shares closed at a new all-time high of $300.35 (on a split-adjusted basis), adding $30 billion to the company's market capitalization of now $1.335 trillion. If you had bought $1,000 worth of Apple shares on January 9, 2007, the day Steve Jobs unveiled the original iPhone at MacWorld 2007, your investment would now be worth $26,103.

Venture capital in the United States began as a cottage industry, notable in the early years for investments in companies such as Intel, Microsoft, and Apple. In 1990, 100 VC firms were actively investing, with slightly less than $30 billion under management, according to the NVCA. During that era venture capital generated strong, above-market returns, and performance by any measure was good. During the peak of the internet boom, in 2000, the number of active firms grew to more than 1,000, and assets under management exceeded $220 billion.

As in most asset classes, when the money flooded in, returns fell, and venture capital has not yet recovered. The number of firms and the amount of capital have declined since the boom, though they are both still far above the levels of the early and middle 1990s. Index funds are passive investing vehicles that duplicate the performance of an underlying index. Total market index funds are based on indexes like the Wilshire 5000, the CRSP US Total Market Index and the Russell 3000, which stand in for the entire U.S. stock market. The indices—and therefore the funds based on them—see only modest turnover, which keeps capital gains taxes low. Investment returns will fluctuate and are subject to market volatility so that an investor's shares, when redeemed or sold, may be worth more or less than their original cost.

Unlike mutual funds, shares of ETFs are not individually redeemable directly with the ETF. Shares are bought and sold at market price, which may be higher or lower than the net asset value . Investment returns will fluctuate and are subject to market volatility, so that an investor's shares, when redeemed or sold, may be worth more or less than their original cost. Taking into account a 2-1 split in 2012, 1,449 shares bought in 1995 for just under $1,000 would now be 2,898 shares worth $435,018 (£297k).

Packaging maker Bemis isn't the most glamorous of companies but its stock market performance definitely has the wow factor. A thousand dollars invested in 1982 would have bought 1,299 shares in the company, which would have turned into 41,568 shares worth $2 million (£1.4m) by 2016. Apple shares have notched up breathtaking gains over the years. In 1976, early shareholder Ron Wayne sold stock that would be worth $35 billion (£24bn) today for a paltry $800 ($3,400/£2.3k in today's money).

And if you'd invested $1,000 at the firm's IPO in 1980, your holding would be worth $300,000 (£205k) today without the dividends reinvested. The US airline has rewarded investors with lavish annualized returns of 26% and several stock splits since 1972. An investment of $1,000 in the company that year would be worth just over $2.2 million (£1.5m) in 2016, not including any reinvested dividends. Known at the time as Flowers Industries, the American baked goods firm made its IPO in 1968. An investment of 80 shares priced at $1,000 would be worth $140,000 (£96k) today, even more if you'd reinvested the dividends.

Yet, some penny stocks do manage to become long-term winners, often due to the success of a single product. Perhaps even more surprising, some of the most famous stocks in the market today have traded down to $5 or less per share in the past. When you see some of the names on this list, you'll no doubt be wishing you could have picked up some shares when these companies traded in penny-stock territory. So a firm that raised a $1 billion fund and charged a 2% fee would receive a fixed fee stream of $20 million a year to cover expenses and compensation.

VC firms raise new funds about every three or four years, so let's say that three years into the first fund, the firm raised a second $1 billion fund. That would generate an additional $20 million in fees, for a total of $40 million annually. These cumulative and guaranteed management fees insulate VC partners from poor returns because much of their compensation comes from fees. Many partners take home compensation in the seven figures regardless of the fund's investment performance.

Total stock market index funds are an ideal choice to diversify a retirement portfolio, plus they're tax efficient, which also makes them a good fit for a taxable brokerage account. Forbes Advisor has analyzed dozens of options to arrive at what we believe are the best total stock market index funds available today. The dot-com bubble bursts, and so does Schwab's unsustainable cost structure.

After CEO Dave Pottruck resigns, Chuck returns to lead the firm. Hi Noel, I always enjoy your articles in the Sunday Mail and over the years your advise has been a great help to our family. We read Making Money Made Simple in the late 1980's and I have re-read the book many times since.

I have also given copies to a number of acquaintances and have had the pleasure of watching some of them follow your advise and prosper. Now, after nearly 30 years we can retire in comfort, our children and grandchildren have carved out their futures based on the foundations you laid and none of us will ever need the support of social security. I guess I'm saying thank-you for having the guts to put into plain English the knowledge you had gained.

I have had a young fellow working with me over the school holidays and he has shown a depth of character and willingness to learn than I rarely see in someone of only 15 years. I would like to give him a few pointers as he starts his journey in life and I recall you mentioned in your Sunday column a few months ago about a Managed Fund or ETF for beginners. The product had it roots in the US and was recently been offered in Australia, it has only small management fee and very low minimum contribution amount to suit young investors. If you are able, I would appreciate the name of the fund to pass onto him. Notable for its many stock splits, McDonald's went public in 1965 and hasn't looked back.

Back then $1,000 would have got you 44.44 shares at the IPO, which would have grown to 33,046 shares worth $4.1 million (£2.8m) by 2016, even more if you'd reinvested the dividends. Key to wartime logistics, Dow has experienced steady growth since the 1940s. A single share in 1940 was priced at $70, so $1,000 invested in 1940 would buy you 14.28 shares, which by 2016 have multiplied to 4,623 shares worth $243,124 (£166k). And if you'd reinvested the dividends, your holding would be in the hundreds of thousands of dollars.

Keep in mind that the price of a stock can fall as easily as it can rise. Investing in stock offers no guarantee that you will make money, and many investors lose money instead. While it certainly would have been wonderful to acquire Apple stock for just a little over $20 a share in hindsight, that doesn't mean the stock isn't now also worth buying at a just under $200 a share.

Apple's financials look strong across the board, and the company has more than established its ability to introduce quality products and win in the marketplace. Therefore, investors may do well to consider buying Apple for future returns on investment. But by the end of 2002, the stock price declined to $14.33 a share, which represented an approximately 40% loss in the hypothetical $100 stock purchase made at the start of the year. By the end of 2004, Apple's stock price climbed to $64.40 per share, making an original four share investment worth $257.60. Kickstarter reports that more than 18,000 projects raised nearly $320 million through its platform in 2012—triple the amount raised in 2011.

Passage of the JOBS Act last year promises to support even faster growth by allowing crowdfunders to invest in exchange for equity and by expanding the pool of investors who can participate. Information provided on Forbes Advisor is for educational purposes only. Your financial situation is unique and the products and services we review may not be right for your circumstances. We do not offer financial advice, advisory or brokerage services, nor do we recommend or advise individuals or to buy or sell particular stocks or securities.

Performance information may have changed since the time of publication. Johnson & Johnson's initial public offering was way back in 1944. Back then, a single share would have set you back $37.50, so $1,000 would have snapped up 26.67 shares.

You'd have been wise to splash the cash as today your holding would comprise 66,675 shares worth $7.5 million (£5.1m) or in the tens of millions if you'd reinvested the dividends. Big pharma firm Pfizer released 240,000 shares of common stock in 1942 – the cash generated helped fund the commercialization of penicillin. One share cost $23.47 so if you bought $1,000-worth in 1942 it would equal 6,135 shares today worth $206,950 (£142k); more if you'd reinvested the dividends.

The secondary market is where investors buy and sell stocks (and other securities such as ETFs, ADRs, etc.). The term "stock market", such as the New York Stock Exchange or the NASDAQ, is essentially a synonym for secondary market. In contrast to the secondary market, the primary market refers to the first time a security is created and sold to investors such as an initial public offering . Growth stocks are anticipated to grow at a rate above the average for the market.

Value stocks are those that tend to trade at a lower price relative to their fundamentals. To determine whether a stock is underpriced, market analysts look at a company's fundamentals relative to its current share price. Growth stocks tend to be riskier investments and generally do not pay dividends. If you are glued to the market report and checking your portfolio value every day, you're playing the wrong game.

Investing properly takes a long view and an avoidance of fads and trends in the market. Considering your age and your life goals, you should have an investment plan built for your life, not just your Wednesday. Avoid reading the financial news every day — returns are noisy and volatile over short timeframes. Don't check your portfolio every day unless you want to drive yourself crazy. This article is issued by Cazenove Capital which is part of the Schroder Group and a trading name of Schroder & Co. Limited, 1 London Wall Place, London EC2Y 5AU. Authorised by the Prudential Regulation Authority and regulated by the Financial Conduct Authority and the Prudential Regulation Authority.