Auto news on Youtube May 2 2018

- Hey guys, welcome to this webinar,

where we show you some cool coding

that you can do with solidity.

And this specific webinar, we are going to be looking

at the ERC721 interface

also known as non fungible tokens.

So ERC721 is a standard interface which came from

something called an EIP

an ethereum improvement proposal,

where anyone can suggest an improvement

and one of the improvement was this ERC721 interface

that would define a standard set of methods

that you can call on a ERC721 on a non fungible token

in order to faster interoperability between different

tokens in the ethereum ecosystem.

So first before we are going to the code,

let's take a second to appreciate the difference

between a fungible token and a non-fungible token.

So a fungible token,

you can think of as something that can be interchanged,

right, so if you think of a physical fungible asset,

you can think of a dollar, the US dollar.

So each dollar bill is interchangeable

for any other dollar bill

and it doesn't make a difference,

you still have the same value.

But an example of a non-fungible physical token

would be something like Pokemon cards

or trading cards because each of those has

you know specific set of powers or skills

that are associated to that card, that token,

and that's why it's non-fungible,

it's not interchangeable for each other

like each of them is unique and has a set of unique

sort of powers or abilities or characteristics.

Whereas with fungible tokens, they are interchangeable

and it doesn't matter which specific one you have

because it doesn't make a difference.

So what I talked about were two physical examples,

but in the digital world

you can also find these examples.

So something like bit coin or ether

or any crypto currency is interchangeable,

not any cryptocurrency but ethereum and bit coin have

sort of fungible tokens, right, so it doesn't matter

which bit coin you have

as long as you have one bit coin.

Similarly with ether,

it doesn't matter which specific ether you have,

but as long as your balance says that you have

one ether, the value is the same.

But if you look a non-fungible token in the digital world,

so an example of non-fungible token,

the most popular example is a CryptoKitties.

So CryptoKitties you can think of as a set of unique

trading cards where each of them represents

a digital kitty that has some special characteristics.

It has you know a special look to it,

it might have some super powers,

it might have some other cool stuff

that you can add in your game.

But the point is that they are not interchangeable.

Each of them is unique like a trading card

and has its own unique value

and therefore you can just trade CrptoKitty for another,

because each of them is unique.

So that being said,

one of the fungible interface examples,

most popular one is ERC20.

So if you are doing an ICO for a token

that you want to be,

you wanted to be listed on other exchanges,

you would probably implement the ERC20 token,

because that would allow other operators

or other exchangers to operate against an interface

without having to know the particular details

about your specific token.

So the reasons behind these interfaces are

to faster interoperability and allow these contracts

and tokens to talk to each other

and also with services outside of ethereum.

So one organization that is a part of building these

standards in ethereum community is OpenZeppelin.

So if you just go to openzeppelin.org,

we can see that it's a framework ,it's a open source,

and it's a framework of reusable

and audited smart contract.

So that's what makes them secure.

They are audited by the community

and they provide these open source implementations

for developers like yourself to use in your projects

and avoid common sort of security mistakes

and just use their code as sort of like a starting point.

So one of the things they provide,

so people can get started, it will take us to their get hub

and if we just look at their contracts folder,

you'll see that they have a bunch of other stuff as well

but if it's over move over to the contracts folder

we'll see a bunch of contracts

and if we go into the token folder,

we'll see folders for each of these various formats.

So we mentioned ERC20 and ERC721,

827 is another interface, but for this webinar,

we are only gonna be looking at ERC721.

And we can that so if we start from this ERC721 basic,

so this just defines the interface,

so this is an abstract class that defines the functions

that your contract needs to implement

if it's going to be ERC721 compliant.

And you can see there is ERC721 basic,

which consist of these functions.

So where do these functions come from?

They came from the EIP and just at the top

you can see a link to the EIP, which you can copy paste.

Let's go and take a look at the EIP real quick.

And it's the complete proposal explaining

you know what are non-fungible tokens,

why is this interface needed,

and what are some of the use cases for us?

So I encourage you to read through this

to learn more about the proposal,

but for now we are just gonna be looking at this code.

But this interface is basically defined in that proposal

and it defines these functions that

you should be able to execute on your token.

So at the top, we see there is a bunch of events

that basically indicates transfers of ownership,

so if you have an ERC721 token

that you wanna give to another person

then there would be events

related to that particular action

and we also have these approval events.

An approvals are basically,

you are authorizing someone else to

you know act on your behalf.

And we will talk about why you might wanna do that

but that is the basic idea behind these approval events,

where you're giving someone else approval to

you know make transfers or take actions on your behalf.

So some of the functions that we have,

just quickly to query,

what is the balance of a particular account,

who is the owner of a particular token,

so each token has an ID

that you can use to query and get information about

who the owners and other information as well.

And you can also just check

whether a token actually exist or not.

Then we have a bunch of functions around approvals.

So you can see with approve you can specify

which address you wanna approve and a particular

token ID that you want to approve them for.

And getapprove will just return whoever is the currently

approved person for a particular token

so you can check if someone is actually approved.

And approval, so the difference between

approve and approval for all is that

you are giving approval for all of your tokens

instead of a particular one in approve.

So in approve for all, you can give someone

authority to act on all of your tokens

and one use case for that might be if you are creating

a new let's say a board game

where you have a bunch of sort of magic cards

and you want to give someone a deck

of like 20 magic cards and you want to approve them

to be able to use that.

So that's one example

of where you could use approvals.

And you also have three functions

related to transferring and we will take a look

at these implementations in a bit

and what the differences between safe

transfer and non-safe transfers.

But this is just the interface,

this is just the events and functions

that we need to implement.

And so opens up link provides us a

basic implementation called ERC721 basic token.

And as you can see it extends

the ERC721 basic interface we were just looking at

and it also use some other libraries to do safe math

and to provide some utility functions on addresses.

But so we're not go into too much details

in this particular implementation,

but we are just gonna take a look at what sort

of information is being tracked in this basic token.

So we are keeping track of

who were the token owners are,

so it's a mapping from a token ID to an address, right,

so we can quickly query,

who the owner is of a particular token.

We are keeping track of token ID to approvals,

right to know whether someone is authorized

to act on a particular token.

And we are also keeping track of

how many tokens a particular address owns.

And we also have another mapping

to keep track of more approvals,

you can have multiple approvals,

so this mapping helps us keep track of that.

And we have some modifiers that we'll see

how to use in a second,

but this is just implementing the interface that we saw

and it provides us some basic functionality

that we can extend to create our game.

So let's see what that would look like, right,

well let's try to create our own game,

which is creating an ERC721 token, a non-fungible token

and we will call it cryptomonsters.

And let's see how we can use this code provided by

OpenZeppelin to implement our own

CryptoKitties like game.

So I am just gonna go over to remix

and let's see what we have here, so I have some of the code

that I have loaded in from here,

so I basically got these source code

directly from this github.

So these files over here I just downloaded

and I opened them in remix

and I just the main one that we're interested in

is this basic token,

but the rest are dependencies for this contract.

But we are gonna write a new one

called cryptomonsters,

so let's open up our new contract.

We are gonna declare the solidity version,

so let's go with .422 and we can see that in the URL like

it supports up to point .4.23,

but 22 is good enough for our use cases.

So we are gonna call this cryptomonsters

and we are gonna say is we are gonna extend the

functionality of the ERC721 basic token.

And it's gonna complain that it doesn't know

which token you are talking about.

So that just mean you have to import

this specific contract into your,

into this cryptomonsters contract.

So all we did is declared our own token

called cryptomonsters that extends

and basically takes the functionality provided

by this ERC721 basic token

and allow us to just focus on hour-specific games logic,

instead of worrying about the details of implementing

the interface and the intricacies of that.

So let me just bring this up here,

so the first thing we'll do is start by defining

a struct for our monster.

And we just call this struct monster

and some of the characteristics

that we are gonna have for our monster

and this can be anything you like depending

on the rules of your game,

but let's give our monster a name.

We will also give them a level or a rank

and they also have some attack power

as well as some defense power.

And we are gonna use this powers

to make our monsters battle

and try to level up our monsters

and get them to be really strong.

So we have defined our monsters struct

and now we are just gonna keep track

of all the monsters that exist in the world.

So we are just gonna define an array,

which is gonna keep track of our monsters.

You could also use something like a mapping,

but we are just gonna use a simple array

and use the index of the array

as the ID of that particular monster.

So the first monster is gonna have index zero.

And another thing will do is keep track of the owner,

of the owner's address

and we'll record this in our constructor

and we'll do this so that only the owner

can create a crypto monsters.

So okay we have our constructor

clear public to make the warning go away.

Here, what's this other warning,

it says, it's duplicated, use constructor, okay.

So this is telling me to use the constructor keyword,

we won't get into that right now.

I am gonna leave that as function

and let you dig deeper into that warning.

But what we are gonna define is the function

to actually create our monsters, right.

So let's define a create monster function

and this gonna be public

and we only want the owner to be calling this

because as the owner of the game,

you should be or you can create any rules you want,

but for this particular game only

the owner will be able to create monsters.

So if we just get the new monster's ID, right,

and which is gonna be the length of the monsters Array.

So when it's empty, the length is gonna be zero,

so the ID of the first monster is gonna be zero

and then we are just gonna say monsters.push,

this new monster and we are gonna give it

some default values to begin with.

So we need to give it a name,

we need to give it a level,

so we'll start with level one

and you can pick any values you want

for the attack power or defense power,

but we are just gonna stick with hundred

as the initial defaults for our monster.

So let's also add a parameter where you can specify

the name of the monster you wanna create.

And we are also going to specify

which address we are assigning this monster to.

So this function will basically create a new monster

and give ownership of that monster that NFT that

ERC721 token to the address specified by this variable.

And so right now, we haven't written any codes so far

in these three lines that actually associates

the monster to this address.

So what we are gonna do for that

is actually use one of the functions provided by

this ERC721 basic token called mint.

And what mint does is actually create

a new token for us and assigns it

to the address that we specify.

So let's go and take a look at this function

in here little quick.

Mint internal function to mint a new token,

reverts if the token ID already exists,

and the two is the address that will own the token

and second parameter is the ID of the token.

And you can see that this logic is already provided,

is already written for us,

so we don't need to worry about building

that logic for ourselves.

Another thing to notice over here is that

when we are emitting

or when we are firing this transfer event

we actually added this emit keyword.

And this is to make it clear that

we are actually firing an event

because if we take out this keyword

then it kind of looks like we are calling a function.

It's indistinguishable from this add token to function.

So in recent version, we added this a emit keyword

to make it more obvious that you are actually firing

an event and not calling a function.

By we are just using that same emit function over here

to say hey emit a new token

and assign it to this to address

and the token will have this particular ID.

And so that's all we need for creating monsters.

So we have created a function

where only the owner of the game,

the owner of cryptomonsters can issue people

new monsters and give that monster a name,

okay cool.

Now we want to provide a way

for the actual game mechanics, right.

So our actual logic of the game,

we want our monsters to battle.

So let's write a battle function

and see what that would look like.

And we are gonna make it public.

And we are going to give it the monster ID

to use as well as the target ID of the other monster

that is engaged in the battle

Right, and we are gonna use one of the modifiers

from our parent classes here called the only owner of

and we are gonna pass it this monster ID.

So only the owner,

only the person who is the owner of this monster ID

can make it battle,

can call this battle function on that particular token.

And so what we are gonna do,

I am just gonna minimize this terminal real quick,

so what we are gonna do is get a reference

to our monsters that are specified

and we are gonna say monster1

equals monsters specified by this ID.

Right and that's just the index in the array.

And the second monster,

monster2 is the target monster.

Okay, cool, so we have got reference

to our two monsters

and now we need to write the logic

that will actually make them battle

and effect their characteristics

like their level, their attack power,

and the defense power.

You can write whatever logic you want, right,

that's up to your creativity, but for this example,

we are just gonna keep it really simple

and we are gonna say that if we attack power

of the first monster is greater than or equal to

the other monster defense power.

Then monster1 will be the winner,

because it has the stronger attack power

than the other monster's defense power.

So in this case what we are gonna say is

monster1.level and just incremented by one

so you level up because you would win this battle

and monster1s attack power would also go up

as a result of this victory.

And let's say it goes up by ten.

But if this condition isn't met, right,

then monster2 will win, right,

so monster2.level will increment by 1.

And its defense power will increase by 10 as well.

So this is, these are the changes

that happens if monster1 wins and

these are the changes that happens if monster2 wins,

but basically with every battle that you win,

you level up and it effects either

your attack power or your defense power.

Sweet, this is all the logic you really need

for a really simple ERC721 token

and we have written a very simplified version

of crypto kitties called crypto monsters where you can

create monsters as the owner of the game

and you can get them to battle each other.

So let's see what this would look like if we run it.

We gonna bring up our JavaScript's VM test block chain

and we are just going to deploy

our crypto monsters' contract

and there is no parameters initially

so just create, right,

and you will see that all the functions that are provided

there is a lot more than we declared in our contract,

right, and that's because we are inheriting from

this ERC721 basic token all this other functionality.

But, okay let's create a monster

and so the owner is the account that deployed

and if create a monster called Pikapika

and we assign it to ourselves,

all right, so this is the address

and we are gonna say create monster,

let's bring up our terminal to see whether our cause

are going through this with the create monster.

And it's succeeded, right,

so now if I check, you know if I just paste

that same address into

here into the balance of function,

we get one, right, because I have one token

that is assigned to me

and we can also check the exist function

so it's the first one,

so the token ID will be zero

And we can check that it exist and the owner

also matches up with our address over here awesome.

Cools so now let's create a second monster as well

and we'll call it Dumbledore,

so create monster and now I wanna check my balance,

I should have two because I have

two monsters assigned to me

and okay so that now I have two monsters,

I can actually make them battle.

The monsters don't have to be owned by

two different addresses

So let's see what it looks like

if we make these monsters battle.

So I am gonna take the monster ID of zero and one

Right, and let's just check our monster statistics

before we go forward.

So for Pikapika and for Dumbledore

the value should be default

because they haven't been in battle

so they are both level one.

But let's bring up,

let's keep a track of Pikapika's power.

So when I click battle,

Pikapika is gonna battle Dumbledore

and I click battle,

so make sure the transaction went through, right,

it was successful and so now,

so my balance will stay the same, right,

because still have the same number of tokens,

but if I check the stats over here of Pikapika,

so if I refresh this I click monsters again,

I see that Pikapika actually won,

so it leveled up and its attack power went up by ten.

So similarly you can battle your different monsters

and level up or and gain more power

and so each of these monsters

through each of their battles,

they will have different levels,

different attack powers, different defense power,

which will make them unique

and you could also attach something

like a cool image to each of these tokens.

But we basically created a simple game

using ERC721 interface

using an implementation provided by open zeppelin.

And if you want to transfer as well,

so let's try transferring one of our tokens.

So Pikapika has the most attack power in the game,

so you know someone is interested

and you know trading something for Pikapika,

so I am gonna so let's say they gave me

like five bucks in person and now I can transfer them

ownership of Pikapika,

so let's just look at our say if transfer from,

I just wanna get look at the parameters that it has

now it's over,

so from to and token ID, right.

So the from is gonna be our author, right

or it's gonna be us, who is the owner, right

and let's say we wanna transfer to the second account

and pass that and zero for the token ID of Pikapika, right

and so right now the owner of Pikapika,

which is token ID zero is the CA35 account,

but after I go through this transfer function

and it succeeds or execution failed.

Let's see why execution had failed,

oh okay, because I didn't copy the to address properly

so let's try this again.

Oh, because I am actually not

Oh I did from the wrong account,

so let me try that again,

I'll try to fix this arguments as well.

So the first argument should be CA35, right

and then second argument should be 147 something,

so this argument is wrong,

so just delete that and I just try this again,

copy and paste 160C, okay so that looks correct

and transferring zero for Pikapika

and we have to do it from the owner account, right

so now if I try to click say if transfer,

I'll do this again, all right

and okay this time execution succeeded,

so now if I check the ownership of

the zero token ID again, this should be different

because I just transferred it over to the second account.

So I click it and I get back the new owner of this token.

So yeah, that's just a very simple example

of how to build a non-fungible token

and how to build a game using some

you know cool game mechanics

that you can dream up of.

So I highly encourage you to check out

this ERC721 basic token further

and read through the EIP

to understand the use cases better

and yeah also check out the code

for crypto kitties a lot of it

but not all of it is available

on places like etherscan,

so you definitely check that out

and learn from that as well

and see how you know they are approaching

their game mechanics.

But yeah, thanks for watching

this simple ERC721 example

and we hope to see you next time.

For more infomation >> How To Build a Simple Ethereum Game - Live Coding - Duration: 30:07.

-------------------------------------------

How to Build a Mobile Workbench | For Beginners - Duration: 7:44.

Hi this is how to with Hannah! I'm spending the next year furnishing my

apartment and do so I'm gonna build every piece by hint by group using my

father's tool bench almost as much as he did and all throughout college I worked

at a hardware store I love both designing and constructing furniture all

my pieces are at first inexpensive there are really simple builds and I use very

common tools to assemble them and in order to dive into this

first I need a workbench hence how to build a mobile work bitch

only power tool used in the project as a drill you're going to need a meter stick

a handsaw the rest of these are optional a painting brush a magnetic strip and

finally hooks to hang all of your tools on the only wood you need for this

project is a piece of plywood four by eight and to assemble it use some wood

screws I use two inch screws as well as half-inch screws and if you'd like to

paint or stain it you can do that as well

step 1 this is the design of what we're going to be building today and these are

the cuts I actually had it done at the hardware store step 2

the first step is to build the tabletop so I select the best looking piece to do

that make a stack of random things the same height as the aprons that way the

top balances on those three points it's a four foot bench so I'm going to do six

screws on either side and the screws are going to be eight inches apart from each

other always drill a hole before screwing

you're screwin because it displaces some of that wood so your wood won't split

you also have a lot more control over the direction that the screw goes in I

select drill bits that are the same width business screw if it didn't have

the clearance continue to drill and screw down the line sometimes wood can

be a bit warped but as long as you do it one by more than you can adjust that you

bring to be in line with the tabletop it can be difficult to get a screw and

exactly flush with the surface using the power drill

so like shown here you can manually adjust the screw to the depth you would

like then I want to screw down both sides and that is my cat knocks over

there he's very sweet he also likes to be in the center of whatever is going on

so he ends up being in a lot of the shots next I screw the sides in it

really doesn't matter which one you do first the short one or the tall one I'm

gonna do the sides into the apron first on either side

and then I'm going to screw the side into the top once I got those sides

screwed in I set it up and it should look something like this for once you

want it to be slanted now we're going to attach the shelf so I attach the shelf

first to the shorter side

measure out the wheel to make sure that you get the correct depth of the shelf

and screw it all in step 3 things that I looked for when I was purchasing the

wheel the first is that the wheel swivels the second is that it locks and

then the third because it is a workbench and I want a really solid surface I got

a plastic wheel rather than a brother wheel is going to do whatever you can to

stabilize the surface and I promise you'll get that now and to attach the

wheels I first marked where the screws were going to go with a sharpie and then

I selected long screws to go down the side of the bench and then shorter

screws that are going to attach to the bottom shelf

if you're having trouble getting the screws in with the drill you can always

use a manual screwdriver to get those in

and now this is no longer just a workbench but a rolling workbench step 4

Step five on the opposite end of the wheels I attached a cabinet handle it

was super cheap like two dollars so you just measure out the distance of where

the screws are going to go drill a hole and then feed the screws through at the

holes that you made to attach the handle now the workbench is super easy to move

next I'm going to hang hooks right below the handle but the plywood is only a

half inch deep and I really wanted more for the screws to hold on to and so I'm

attaching a piece of scrap wood to the back just simply by gluing it I laid out

all my tools on the ground how I'd like them to hang on the side of the

workbench and marked all of their locations and use that piece of scrap

wood to mark where I'm going to drill the holes for the hooks you can hang

whatever tools you want I hung the tools that I use most often because they are

in such an accessible location I hung a sawdust brush a rubber mallet a quick

square your standard hammer a large putty knife and a small putty knife I'm

gonna be moving this workbench a lot I'm gonna need an extension cord so that I

can use my electrical tools wherever I am these magnetic strips were on sale

for a dollar ninety-nine so I got three of them and right now I'm just measuring

out to make sure they're level and centered

first I'm going to take my pliers groove joint slip joint linesman long nose side

cutter magnetic telescope most dot beat measure box cutter both Phillips and

flathead screwdrivers level my socket wrench adjustable wrench and a wrench

set later I also added an exacto knife scissors and a crowbar

and now my mobile workbench is complete

if you have any questions about the spill how I did it or questions about my

future builds you can put it in the comments below if you liked it like it

next week I'm going to build a sort of basic but rustic bench so if you'd like

to see that you can hit subscribe and get notified when I do pose I'm going to

attempt to post on Tuesdays but not making any promises thank you guys so

much for watching and I'll see you next time

For more infomation >> How to Build a Mobile Workbench | For Beginners - Duration: 7:44.

-------------------------------------------

Building a Timber Framed Garage - featured on ITV - Duration: 11:17.

[music]

Narrator: Improving our homes can transform how we live, but, if you think smart and stay

on budget, it can also increase the value of your home and make you lots of money.

So, time to find out which will make the most profit and win "the home game" today.

First, we're off to Nottinghamshire to meet John and Pat, who live in the village of Greenlee.

Pat: We love it.

Absolutely love it.

We are out in the country, which we like.

John: We moved from the centre of Doncaster, to move to the country.

Pat: When you open the gates and you come in, I know I'm home.

Narrator: It's a small village of 800 people, on the Yorkshire border, popular with commuters

to Doncaster.

Picturesque Gringley was mentioned in the "Doomsday Book" and today is a conservation

area with large Georgian houses and old cottages.

So, you may be surprised to hear the average home here costs under £230,000.

John and Pat have lived in their period property for 16 years.

Pat: They're all original features.

I just love the wood, and I like the curves.

Narrator: John works in construction, while Pat hosts weddings in their spacious grounds,

and they both love a bit of home improvement.

Pat: We get a project and we do it properly, and then we go on to the next project and

move on.

John: We've done a lot of renovation to it and repair to it, the balcony out there.

Narrator: Sounds like they come with plenty of experience for the home game, but before

any work starts, we need to know what their Georgian property is worth.

Real Estate Agent: This house is quite exceptional for the area.

It's dated back about 300 years.

Four reception rooms, five bedrooms.

Not only as a house, a grade 2 listed and quite special house, but the grounds are quite

magnificent, too.

In the current market, I value this property at £925,000

Narrator: It's a dream country home and John has plans to make it even more perfect.

Pat: The problem is, John's always wanted a classic car.

John: I can't use the garage, because the garage is used for wedding stuff and for gardening

stuff.

Narrator: Nearly half the 11 million garages in Britain aren't used to store a car, but

instead, are used for storage from workshops.

Pat: I've got a ride-on mower, we've got work benches, I've got storeroom in the back, so

no, we've got no room.

John: So, I'd like to put this classic barn up.

Narrator: The oak barn sounds lovely, but the property already has a lot of outbuildings,

so another may not add value to the property.

Real Estate Agent: There's offices, storage...

Most of the outbuildings at the moment are being put for use.

Really, there's not any areas were I see any huge gain in value can be made from the property.

Narrator: It's not encouraging news, but this is no ordinary outbuilding.

John and Pat plan to build a bespoke natural green oak barn, with traditional clay tile

roof and paved floor.

A classic construction for a classic car.

John: This is the area where the classic barn is going.

Pat: We'll start at the back, here, and it will probably go up to about here.

The barn is gonna be opposite to the three bay garage.

We've got to marry up and nice, so that it just looks as though it's always been there.

The features are beautiful.

Leaving it open so you are exposing all of the beams and then we're gonna have one bay

that's closed, for your classic car.

John: Yeah, and that's where the classic car is going.

Narrator: Sounds impressive, but this traditional oak-framed barns do not come cheap.

John: The barn itself, the oak part, is £35,000.

The substantial foundation will probably be around £20,000 for that.

So, probably, a budget around £65,000.

Pat: Did you really say that much?

John: Yeah, it will be.

Narrator: John is maybe airing on the side of caution.

Let's see how the figures add up.

Narrator: Their house is valued at £925,000.

The budget is £65,000.

So, it will have to be worth more than £990,000, if they're to break even.

John: It's time for me to, sort of, I you like, enjoy myself, and that's where the classic

car comes in.

Now we can afford a car and afford a building to house it.

It's more of a pleasure, rather than a financial reason for building it.

Narrator: This clearly is a passion project for John.

Our agent, though, thought this wouldn't add any value to the property, but anything can

happen on "The Home Game".

Let's find out.

Seven weeks digging dust and dirt, in an instant for you, as we return to the Gringley oak

barn.

[music]

Narrator: From a patch of grass and shrubs, rises a classic green oak barn, beautifully

in keeping with the period home.

John: Well happy with it.

Pat: I think it's gorgeous.

I love it.

John: We're over the moon with it.

Narrator: It's a fine piece of traditional craftsmanship, but right from the start, there

was a flaw with the foundations.

Pat: The weather changed the day the concrete came and we had three wagons turned up, and

the heavens opened, and they were up to their legs in concrete, but they did a brilliant

job.

Pat: We've got a slight problem that we can't find the drain.

A bit of a setback, because we wanted to do the block paving very shortly, and it just

put a bit of a standstill on things but, such is life.

Narrator: In the end, they had to lay and extend extra pipes.

John: It's worth putting proper drainage in.

Narrator: But it was an unplanned expense.

John: Just the drainage on itself was an extra £1,000.

Narrator: With the fundations firmly in place, the impressive and expensive cobbled area

could be laid.

John: The block paving cost us £5,000.

That was twice as much as what we'd originally thought it would be, if it was in concrete.

It gives it a fully luxury finish.

Narrator: It might look good, though it was another unexpected cost.

And though the build overrun by a week, it was worth the wait.

The barn has many traditional features, from handmade rosemary clay roof tiles, to a generous

open span oak frame.

John: It's everything that we could have asked for, really, and certainly the finish of it,

I'm well happy with it.

Narrator: Good job, as these oak barns can last around 200 years.

John: These doors that we got here where £2,500.

So, if we've gone for doors on the other two bays, you're talking another £5,000 on it.

I'm happy enough with just one set of doors on, to be honest with you.

Narrator: They overspent on some features, but saved on others such as labour.

Local builders who did everything bar the woodwork.

John: I wanted the local workmen to do the work.

We were convinced that we were gonna get a quality job done and I think we saved from

our original budget.

Pat: Because John's now got the garage, it's a lot better for me.

It takes away the guilt.

Narrator: Pat felt bad because she is using all the garages for her business, but not

anymore.

John's now got an amazing garage of his own, for his love of classic cars.

John: It really is good when you come down the drive.

Pulling into that is a good feeling and I was very happy with it.

Narrator: This oak barn was never going to be on a shoestring, with John and Pat prepared

to invest some serious cash.

John: Our initial budget was £65,000.

What we've actually spent is £58,000.

Well pleased to be on the budget.

Pat: We're just very lucky with it.

John: We're fortunate with it.

Narrator: It helps they've built contingency into their budget, that they never used.

On employing local labours, saved money.

The debate now is whether garage will turn them a profit.

John: I would be disappointed if it didn't add some value to the property, however, that

is not the number one criteria.

The aim was to have a nice building..

Pat: For us, for you.

John: Yes, for us to...

Pat: For his car.

Narrator: Our estate agent didn't think much value could be added to the property, but

it's time to find out.

Real Estate Agent: It's been built to a very high standard, finished very much in keeping

with the surround.

They've done a beautiful job.

I'd now suggest marketing property price in the region of £950,000.

Narrator: That just leaves us to do the maths.

Before the work, John and Pat's period property was valued at £925,000.

The oak barn came in seven grand under budget, at £58,000.

The new valuation, with the new garage, was £25,000 higher, but before agent's fees,

this means a loss of £33,000.

But for John and Pat, the property has at least risen in value.

John: Yeah, that's...

Pat: That's fine.

I don't know.

I mean, I think that's fantastic, but I wouldn't have expected that at all.

John: No. no I'm happy.

Pat: I'm very happy with that, actually.

Narrator: Passion projects like this very rarely make any money, but what's really important

to John is that he's got a classic barn to put his classic car.

I wonder if our next player will pack a profit.

[music]