/dpt/ - Daily Programming Thread

first for anon who deleted his new thread because this was made slightly earlier

>>57381673
>anonymous
First for C#

>>57381673
working on a new statistic theory

File: anal beads.png (19KB, 347x487px) Image search: [Google]

19KB, 347x487px

>>57381701
Fuck me.

>>57381673
>What are you working on, anonymous?
Nothing useful, pic related.

>Cape Verdian double dong

Give me something fun to do, /dpt/.

import Data.Function (on)
import Data.List (find)
import System.Environment (getArgs)
import Text.Printf (printf)
vowels = "aeiou"
vowelEq1 = on (==) $ filter $ flip elem vowels
vowelEq2 = on (==) $ map $ flip find vowels . (==)
main = do
  [w1,w2] <- getArgs
  let pr :: Int -> Bool -> IO ()
      pr x y = printf "vowelEq%d returned %s\n" x $ show y
  pr 1 $ vowelEq1 w1 w2
  pr 2 $ vowelEq2 w1 w2

>>57381729
rewrite it with markov chains

>>57381797
>with markov chains
How would that work?

I guess I could take that output and regenerate more things from that, but I'm not sure what the end-goal is.

C question:

Why is signal-related stuff part of the C standard? It looks too platform-specific to be part of standard C to me. Does Windows support signals?

>>57381809
>Does Windows support signals?
hell no

>>57381809
c is only here to abstract the underlying hardware architecture, not the operating system (c was made to develop unix)

{-# LANGUAGE MonadComprehensions #-}
import Data.Function (on)

view :: [Char] -> [Maybe Char]

vowels = "aeiouAEIOU"
view x = [ x | x `elem` vowels ]
vowelsEq = (==) `on` map view

>>57381876
whoops

view :: Char -> Maybe Char

>>57381809
I suppose they were useful enough.
Even if the operating system isn't going to give you any signals, you can still signal yourself with raise().

Even then, it allows you to write standards conforming code, which uses signals (which is central to *nix, and C is heavily tied to *nix), and still have it work on other platforms, even if the signals will never actually get used.

File: anal beads.png (25KB, 687x193px) Image search: [Google]

25KB, 687x193px

>>57381729
>>57381797
Low order markov chains are a mistake.

File: anal beads.png (31KB, 713x245px) Image search: [Google]

31KB, 713x245px

>>57381935
And here's order 3 chains

some 9/10 twitter handles in here

File: 1478104797366.jpg (13KB, 257x196px) Image search: [Google]

13KB, 257x196px

https://www.youtube.com/watch?v=bl8jQ2wRh6k

>>57381900
I won't deny that they are useful, but it seems to me like the language standard was the wrong place for them. If your platform is POSIX-compliant, you already have them, and if it isn't, a standard C compiler targeting a non-compliant platform now has to "support" signals.

>Even if the operating system isn't going to give you any signals, you can still signal yourself with raise().

Fair enough, though I'm not sure whether this is preferable to alternative approaches that don't imply a particular platform.

>Even then, it allows you to write standards conforming code, which uses signals (which is central to *nix, and C is heavily tied to *nix), and still have it work on other platforms, even if the signals will never actually get used.

I'm not sure I follow. Why do signals need special treatment, when most other platform-specific code gets handled with #ifdefs and compilation flags?

>>57381809

To write fork bombs that won't stop at CTRL + C.
Ah well, what a prankster Kernighan was..

(unfortunately you can't catch SIGKILL, though)

let is_vowel = function
  | 'a' | 'e' | 'u' | 'i' | 'o' -> true
  | _ -> false
let purge_vowel x = if is_vowel x then x else ' '
let vowel_eq s1 s2 = String.map purge_vowel s1 = String.map purge_vowel s2
let () =
  Printf.printf "vowel_eq = %B\n" @@ vowel_eq Sys.argv.(1) Sys.argv.(2)

>>57381876
>{-# LANGUAGE MonadComprehensions #-}
>view :: Char -> Maybe Char
>view x = [ x | x `elem` vowels ]
Curious!

>>57381988
Probably all the same reason why multithreading is in the c11 standard but it's been years now and still not implemented in glibc.

>>57381993
MonadComprehensions generalises list comprehensions to arbitrary monads

[ x | becomes pure x / return x
| x <- mx
is mx >>= (\x -> ...) or
do { x <- mx; ... }

| condition
is (guard condition *> action)

[ x | x `elem` vowels ]

specialised for Maybe, is

Just x (if x `elem` vowels)
Nothing (otherwise)

I suppose it might've been better to right it that way

view x | x `elem` vowels = Just x
       | otherwise       = Nothing

but the idea is that you remove the unnecessary structure (all non-vowels become

>>57382048
>but the idea is that you remove the unnecessary structure (all non-vowels become
become Nothing (aka ()) while the vowels retain their uniqueness (which vowel they are)

so you get rid of the details that you don't care about for the comparison by mapping them to Nothing

>>57381988
Signals themselves aren't actually too complicated (from a userland perspective, not a kernel one).
It's basically just a set of function pointers that are called, but it might happen at any time. It's not something that going to add a huge amount of unnecessary implementation details.
For an implementation that isn't going to have the OS giving it signals, raise() could be implemented as simply as

static int (*sigabrt_handler)(int) = default_handler;
static int (*sigfpe_handler)(int) = default_handler;
...

int raise(int sig)
{
    switch(sig) {
    case SIGABRT:
        sigabrt_handler(sig);
        break;
    case SIGFPE:
        sigfpe_handler(sig);
        break;
    ...
    default:
        return 1;
    }
    return 0;
}

Do you guys know of any relevant resource to learn wordpress development? From a programmer's point of view.
Most of what i found (even full fledged courses) only deal with the approach of "you don't even have to code!", and that's just basic installation and a little css. What i'm looking for is more geared towards plugin and theme development.
[spoiler]don't judge gotta make some money on the side to buy vidya[/spoiler]

>>57382091
this isn't /wdg/

>>57382103
Sorry, had /dpg/ bookmarked for years, didn't know there was a /wdg/.

>>57382122
>/dpg/
No you haven't.

>>57382126
http://boards.4chan.org/g/catalog#s=daily%20programming%20thread

>>57382068
That does look pretty simple... I figured they need some sort of OS support for context switching or whatever. Thanks for the help!

>>57382147
>That does look pretty simple
This is for a hypothetical, minimal C implementation.
For one that has "real" signals, and not ones just called by raise, it would be much more complicated.
Most of the heavy lifting would be done by the kernel, though.

>>57382180
Welp, now I feel I'm back to square one on the matter.

>>57382048
Yes, I've found the translation rules at https://ghc.haskell.org/trac/ghc/wiki/MonadComprehensions.
It becomes precisely

guard (x `elem` vowels) >>= return . \() -> x

where guard is Just () when the condition is true and >>= returns Nothing when the first argument is Nothing.
I wish I knew some haskell, so it would be monad comprehensions instead clumsy flip find vowels . (==).

>>57382425
>>= return .
is
>>

the real difference is just the method, you could easily have just done the function version, or if you weren't using Maybe's then this instead

view x | x `elem` vowels = x
       | otherwise       = '_'
vowelEq = (==) `on` map view

>>57382511
and this LITERALLY turns "hello" == "derpo" into "_e__o" == "_e__o"

File: weird.png (38KB, 1898x276px) Image search: [Google]

38KB, 1898x276px

on some focus

Am i retarded or is it actually hard to find some info on what keys are called in C such as A_KEY, LEFT_KEY etc.?

>>57382620
Yes, you are retarded. It depends entirely on the API.

>>57382620
can you not use the ascii table? or do you need it to respond to the serial port?

>>57382624
>>57382628
nevermind i am retarded, fuck me

>>57382511
>is
I don't see it. It's fmap rather.
>then this instead
Yeah, that's exactly what that ocaml program does (but using ' ').

I'm just curious. Do you study CS at a uni?

>>57382637
what was it?

>>57382641
found in api documentation like >>57382624
said

why do whites and chinese make computers hard? why don't they make them easy like the TV?

>>57382639
Oh, yeah it's fmap

And not exactly, I do a shitty programming related course at a former polytechnic, and most of what I learn has been on my own, not from the course. A lot of the stuff at the course you wouldn't even need to study for.

In other words, I ""study"" ""CS"" ""at"" ""uni""

>>57382667
They make their own lives hard. The rest just kind of follows. But really, it has a lot to do with not knowing who to trust. That's due to how much power they give their women. And that's only due to how much power other people give their women, what with wanting specifically white or asian women for god knows what reason.

It's also because of how it's taught and how the requirements are abstracted from a not so whole whole. A company doesn't need a computer guy. It needs a guy that can stack JS calls.

>>57382702
And there's million ways to stack JS calls but only the stupidest of them are willing to call it the best method. And usually those are the ones people believe. If non white or asian women were to ignore the white and asian women a lot better we could have some peace for a bit because there's be no pecking order to attempt to overcome.

I'm going to sleep.

>>57382639
>>57382672

In fact in this case it's a lot like >>

m >> e
m >>= const e
m >>= \_ -> e

since there's only one () and you don't really use it
guard (x `elem` vowels) *> Just x
(*> is applicative >>, Just is Maybe return)
was what I was thinking

What are the best languages for a DBA to know besides sql/oracle etc.?

>>57382745
English

>>57382672
I somehow expect all users of haskell to be related to writing small language for theoretical computer science. Just a stereotype.
>>57382733
Yeah, I understand your reasoning now. (I have to admit that I don't remember the definitions of Maybe's Monad and Applicative instances well.)

    Just _m1 *> m2      = m2
    Nothing  *> _m2     = Nothing

>>57382851
>I somehow expect all users of haskell to be related to writing small language for theoretical computer science. Just a stereotype.
If it makes you feel any better, I WISH I could be writing small languages for theoretical computer science. Maybe when I've graduated.


> I don't remember the definitions of Maybe's Monad and Applicative instances well.
Maybe a is basically just Either () a, where Nothing = Left () and Just = Right.

It's also like [a] for a maximum of 1 element.

It basically just short circuits. Binding asserts that all the inputs are Just's, else it returns Nothing.

So

Just _ >> x = x
Nothing >> _ = Nothing

>>57381965
those features have long been available. Unless there's a high profile company using any Lisp, adoption rates will stay the same.
good on that company for using Lisp tho

File: Capture.png (25KB, 744x709px) Image search: [Google]

25KB, 744x709px

Thanks for "Nothing", Haskell.

>>57381673
Who use D here?

Nth post for D.

whats the best coding language

>>57383051
D

>>57383051
JSON

>>57383051
gentoo
install it

>>57383051
>whats the best kitchen appliance

>>57383235
Fuck off you fucking cunt. I hate you. You are the worst fucking poster. Every damn time. It's because you use a shitty language and don't want anyone to be allowed to take you up on it.

>>57383235
Oven obviously.

>>57383254
I use multiple languages.

Some languages are great general-purpose languages, but saying a language is the "best" without some context in what is the "best" at is just silly.

>>57383261
Ovens suck at making ice, and I run a snow-cone stand.

Fuck ovens.

You should see how this works for programming languages, too.

I'm trying to figure out an algorithm to find islands in a 1D array, ie.

[0,0,1,0,0,0,0,1,1,1,0,1,0]

Would give me some list of structures/objects with an offset and size ie.

{{Size: 2, offset:0}, {Size: 4, offset:3}, {size:1, offset 10}, {size:1, offset:12}}

Right now my algorithm doesn't seem to be working 100% properly and I'm not sure why. Any ideas?

int start=0;
for(int i=0;i<map.size();i++) {
        if(map[i] == true)
        {
            if(start!=i) {
                
                Island isle = Island();
                isle.offset = start;
                isle.size = size;
                size = 0; //Reset size.
                islands.push_back(isle);
            }
            else {
                start=i+1;
            }

        }
        else {
            if(i != map.size() - 1)
                size++;
            else {
                Island isle= Island();
                isle.offset= start;
                isle.size= size;
                islands.push_back(isle);
            }
        }
    }

>>57383277
>Ovens suck at making ice
I'd rather do without ice than cooked food you stupid retard. There's a lot more demand for hot food than snow cones too.

why is pixiv so shitty? and why do japanese use it?

>>57383285
in Haskell there is a function group that does most of the work

>>57383314
less filthy gaijins in pixiv thats why.

Post real life experiences when you're CS degree has helped you in any way.

heres mine:
never.

>>57383294
But there IS demand for snow cones. Some stands are quite profitable.

Also, what about storage of perishable foods? Life would be really difficult without refrigeration.

Both an oven and a fridge/freezer are necessary in a proper kitchen. Both have their place, and both do different things.

Now, an oven and a range both heat up food, and you can create an oven-like environment on a range (with the right tools), and you can create direct-heat in the oven, but they're both more efficient at different things.

I wouldn't want to boil water in an oven. Sure, I could, but it's more efficient to use the range top.

The problem is, metaphorically speaking, some anons are only using ovens, when other appliances could suit their needs in a better way. They just haven't purchased any other appliances (learned any other languages/frameworks/etc.).

>>57383285
CS grad here.

here you go, peasant.
This should get you on track:
https://interactivepython.org/runestone/static/pythonds/BasicDS/SimpleBalancedParentheses.html

>>57383322
good to know

File: 1478209377837.png (24KB, 332x356px) Image search: [Google]

24KB, 332x356px

>>57383323
yes

>>57383351
>Life would be really difficult without refrigeration.
we didn't always have this. We survived fine without, we are not dependent on this, so we can scrap this.

>>57383358
I don't really see how using a stack helps with that at all.

>>57383322
Any idea on an equivalent C++ function?

>>57383351
>But there IS demand for snow cones.
Less than for ovens.

Ovens objectively more useful, therefor are superior. QED.

>>57383351
This isn't an appliance thread you fucking ck, this is a fucking progrmaming thread

Get out

>>57383387
you should have went to a good uni.
feel sorry for you.

>>57383387
Wait I'm an idiot, I see how the stack does it. Thanks kind anon.

>>57383394
everything is a subset of programming.

>>57383372
>>57383389
>>57383394
>missing the point this hard

I'll make this easy for you: if you only use one programming language, you're literally a pajeet-tier code monkey.

There is no single language that is the best at every task.

>>57383404
you're welcome, just doing my good deed for the day.
you kind of have to when you're as privileged as me.

>>57383410
>I'm a fucking retarded idiot
Thanks but we already knew
Thank you for derailing the fucking thread, AGAIN, and not answering the fucking question

>>57383410
>There is no single language that is the best at every task.
Nobody ever said that. Some langugaes are better than others.

I know lots of langugaes and use the best one for the given job.

>>57383410
>>57383421
all me.

>>57383285

#include <cstdio>
#include <vector>

int main(int, const char **)
{
    std::vector<bool> map{
        true,true,false,
        true,true,true,
        true,false,false,
        false,true,false,
        true,
    };

    bool inIsland = false;
    unsigned size = 0, offset = 0;

    for (int i = 0; i < map.size(); ++i) {
        if (!map[i] && inIsland) {
            inIsland = false;

            std::fprintf(stdout, "Size: %u, Offset: %u\n", size, offset);

            size = 1;
        } else if (map[i]) {
            if (!inIsland) {
                inIsland = true;

                size = 1;
                offset = i;
            } else {
                ++size;
            }
        }
    }

    if (inIsland) {
        std::fprintf(stdout, "Size: %u, Offset: %u\n", size, offset);
    }

    return 0;
}

>>57383410
>what is C
>what is ASM
>what is python
You wasted your life learning all the useless meme languages. Just end yourself, faggot.

>>57383441
C is deprecated
ASM is deprecated
Python was never good in the first place

>>57383441
>python

you lost me there.

>>57383421
>not answering the fucking question
It's a bad question. There is no objective "best programming language".

>>57383427
The original post asked what the best language was.

That's implying that there is a language that is objectively the best, meaning, the best for everyone to use.

Different languages are "the best" for different people, depending on what they do.

>>57383441
What are you saying here? Are you claiming that one of these languages is the "best" language?

>>57383449
>ASM deprecated
I see. Math is deprecated too right?

>>57383463
we need a new numbering system. We've been doing math all wrong all this time.

Its time to start over from scratch.

>>57383461
My point is one language is enough if you know what you're doing.

>>57383410
>>57383441
>there is no single language that is the best
>responds with three languages almost as if to refute this

what

>>57383461
1) You are autistic and do not understand human communication
2) Some languages ARE better than others
3) Programming is not just the "different tools for different jobs" bullshit you faggots always fucking spout

If I get admitted to a college for the CS major and live on the campus, will my roommate be hot and will he do perverted things to me?

>>57383483
yes, call me.

>>57383473
You're absolutely wrong.

You can do pretty much everything in a great general-purpose language, but you can't do everything in the most computation-efficient and time-efficient way with one single language.

>>57383499
Java in a nutshell.

>>57383473
hammering a screw is ok if you know what you're doing, all you have to do is hammer the head sideways

>>57383499
>you can't do everything in the most computation-efficient and time-efficient way with one single language
Yes you can

>>57383461
>That's implying that there is a language that is objectively the best, meaning, the best for everyone to use.
You have asperger's syndrome.

>>57383513
the moment shit goes in the JVM, it already lost.

>>57383511
>hammer screw
OH FUCK OFF
Stop this bullshit now you fucking faggot
I'll fucking stop arguing against you if you just shut the fuck up

That is basically a fucking facebook platitude
That's how fucking cancerous you are

>>57383525
I never said anything about Java

>>57383531
>I'll fucking stop arguing against you if you just shut the fuck up
This is high grade triggering

>>57383499
>>57383478
You can do everything in ASM and C. It's not wrong.

You only need to know one high level language, like python or lua.

>>57383550
or javascript + node

>>57383545
>ha i annoyed you therefore i won
This is high school arguing

>>57383480
>1) You are autistic and do not understand human communication
I think I get by quite fine.

>2) Some languages ARE better than others
Within certain contexts. You can say that Language A is a better general-purpose than Language B, or that Language X is easier to read than Language Y. You can also say that this language is better than this other language at literally everything. But there is no language that encompasses every use-case preference that 100% of humans have and need for their project requirements.

>3) Programming is not just the "different tools for different jobs" bullshit you faggots always fucking spout
There are better tools for different jobs. Sure, you could write your website using only C, but that would take fucking forever. From a business-case perspective, it simply doesn't make sense.

>>57383513
No, you can't.

If you spent one year learning two languages, and needed to do a myriad of tasks ranging between web dev, mobile app dev, sys admin automation, server administration, cloud service administration, data integrations... Those two languages would show their differences very quickly. One language would not encompass all of these things *in the most time- and computation-efficient way*.

>>57383554
kys

>>57383472
Sounds great. I'll start on the logo.

>>57383556
>Within certain contexts.
No, some languages COMPLETELY defeat others.

>>57383559
embrace the future faggot.

>>57383560
I'll start new number symbol designs.
I'll upload mock ups to imgur
stay tuned

>>57383550
>It's not wrong.
Yes it is.

Just because you can do everything in ASM, doesn't mean that it is "enough".

If you take 6 months to do some basic crud shit with web integrations because you're using ASM, it's not "enough". That project is a failure.

High level languages are not always sufficient for performance requirements.

Try again.

>>57383562
I even said that in my post, which you seem to have failed to read completely.

However, among the best languages that are better than their counterparts in every way, these languages do not objectively best each other in every single way.

There are languages that are literally the best within a specific context, yet they fail in all others. This means that no language can be the best in every single possible context that a project requires.

>>57383572
>imgur
Too bad you're an idiot.

>>57383556
>Sure, you could write your website using only C
Where's akariboobs? How long did it take him to make akaribbs?

>>57383593
Okay, I get it now Java Pajeet.

we nuke india when?

>>57383598
downvoted >(

>>57383600
Longer than it would have taken him to create it in another language more suited to the task, had he been as experienced in that language.

>>57383611
Are you flailing to internal justify your mindset at this point?

I do not program in Java, nor do I care for it. That's a silly little way to lash out when you have no argument.

Java is not the best language, and it hardly does anything better than any other language, but it is the "best" in the context of job availability. There are objectively more jobs for Java than any other language (sans ubiquitous things like SQL and Javascript), but I think we can all agree that Java is not the "best" language.

It's about context, anon. Kind of like morals and ethics and stuff.

Hell, maybe Mormons can't use Java because they can't drink coffee.

>>57383600
somewhere around several weeks, compared to an about an afternoon it'd take in flask/django/ror

why do pajeets smell so bad?

>>57383643
In a world where we have python, go, and rust there's really no reason to do new projects in Java.

>>57383676
I don't disagree, but I fail to see what that has to do with the price of rice in China.

Also, some companies may have 200 developers on staff that already know Java, without much other language experience.

From a business-case perspective, the popularity of a language and dictate the feasibility of a project being done in that language from a cost-benefit perspective.

This is why, regardless of how shitty it is to program in Java, Java has still dominated the job market because it had such a strong market share in the past. This causes more people to learn it when causes more projects to be done in it.

>>57383643
I don't think you have realized that every language that's not C is shit.
You want arguments? Yes. Let's see
>No fucking OOP retardation, no fucking bloat and best fucking performance.

The reason it's actually good is it was made by people that actually fucking understand how computers work.
In fact everything "modern" is just a bunch of kids trying to be cool.

Also, python is good because it's a fucking snake. Fuck yououuu

>>57383704
how to spot an unemployed person

>>57383731
how to spot a social slut

File: Capture.png (12KB, 987x297px) Image search: [Google]

12KB, 987x297px

int main()
{
    int x[5][5];
    x[2][3] = 23;

    cout<<*(x+(2*5)+3)<<endl;


    return 0;
}

Why does this code print out the MEMORY ADDRESS instead of the damn value that it points to??

>>57383704
So which language do you think is the "best"?

C or Python?

Is C the best web development language? Is it the quickest way for most developers to make a small data integration? A mobile application?

Does Python have the best performance of all languages ever made in doing physics computations?

Are either of these the "best" language for a project being developed by someone who has 20 years of C++ and Javascript experience, and no C/Python experience?

Please, anon, I'm trying to figure out what you're actually trying to say. What statement are you making? What is your claim that is to be universally prescribed to the world?

>>57383754
array of array of int
add to it
array of array of int
dereference
array of int

array of int ~ int*

dereference it again

>>57383704
>I quite literally know nothing about programming but here are the canned arguments I've read on /g/ in the past

>>57383756
>So which language do you think is the "best"?
>C or Python?
Wow, brilliant set of fucking options there

>>57383779
Did you read the post that is being responded to?

Those were the two options the other anon gave.

>>57383765
Oh i see, thanks!

How do I break the news to my Javafag friend that he overengineered his pet project to hell and back and that he should just throw it all away and start over?

>>57383806
OOP is not engineering

>>57383756
Web in C is easy, just open a TCP server and read the HTTP specifications. If one only know Javascript he should burn himself.

Python is just an example of high level scripted language. It could be ruby, lua, haskell or anything as long as performance doesn't matter. Just pick what looks comfy.

>What is your claim that is to be universally prescribed to the world?
Delete everything unnecessary: merge math, english/lojban and CS in a single universal language, fucking done.

>>57383806
if it works, I don't see a problem with well structured OOP.

you should tell him to implement tests on all his code instead.

File: one-smug-man.jpg (22KB, 480x479px) Image search: [Google]

22KB, 480x479px

>>57383860
>well structured OOP

>>57383852
>Web in C is easy, just open a TCP server and read the HTTP specifications
kek, you forgot the part where it's "time consuming" and "error prone"

>>57383882
kek you forgot the part you're basically letting others solve your problems
>you're literally nothing

Object-oriented programming generates a lot of what looks like work. Back in the days of fanfold, there was a type of programmer who would only put five or ten lines of code on a page, preceded by twenty lines of elaborately formatted comments. Object-oriented programming is like crack for these people: it lets you incorporate all this scaffolding right into your source code. Something that a Lisp hacker might handle by pushing a symbol onto a list becomes a whole file of classes and methods. So it is a good tool if you want to convince yourself, or someone else, that you are doing a lot of work.

>>57383878
when done right, its beautiful.

>>57383852
>Web in C is easy
That's not the point. It's not the most efficient language to write websites in when framed in a cost-benefit perspective. It is going to taken even a seasoned C programmer significantly more time to produce some sets of requirements as opposed to an adequate Rails or Django programmer.

I see that you've avoided the question and failed to say which of the two is the "best" language

>merge math, english/lojban and CS in a single universal language,

Sounds bloated as fuck, I'm not installing that shit.

>>57383894
right why don't you just solder your own CPU anon then? what are you? a faggot that let others solve his problem? come on, you're better than that

>>57383894
> this used to be me.

growing up feels pretty comfy. desu desu.

>>57383899
no it isnt

>>57383894
Do you live innawoods and create your own infrastructure?

What the fuck is wrong with you cunt NEETs?

Go do an actual project someday, and you'll understand why high-level languages and OOP exist.

Before the autistic responses come, I'm not saying that OOP or high level languages are the best solution to every problem, but they certainly help in many situations.

>>57383932
thats just your opinion.

>>57383949
>>57383932

All of the good parts of OOP are available a la carte in languages that care about programmer freedom so why limit yourself to a language that forces you to have all the good things and all the bad things all the time?

>>57383894
>He thinks he can do a better job at implementing an http server than what the people behind nginx did in less time that it would take for a php dev to shit a web app

>>57383957
>good parts of OOP
???

>>57383972
spotted the NEET

>I see that you've avoided the question and failed to say which of the two is the "best" language
Depends if you're smart enough to use C efficiently.

>>57383909
>>57383912
>I like cum
>hur duh I'm an grown shit adult
Fucking degenerate monkeys, please don't reproduce.

File: baka_big.png (2MB, 2000x2000px) Image search: [Google]

2MB, 2000x2000px

>>57383972
>>57383949
>>57383932
>>57383899
>>57383878
What is OOP?

Shouldn't we agree on a definition before we argue about it?

>>57383983
xdddd

>>57383990
No

>>57383990
> what is OOP?
fuck you Kyobei, go back to /wdg/

>>57383972
Everything except encapsulation (in the data/code binding sense) and inheritance, really. So everything that isn't intrinsically object-oriented.

>>57383852
>Web in C is easy, just open a TCP server and read the HTTP specifications
Its even easier if you use something like inetd, a super-server which handles the sockets/concurrent connections. HTTP request comes in on stdin, HTTP response goes out on stdout.

>>57383990
POO is shit, what's so hard to understand?

>>57384008
>the good parts of object oriented programming are the parts that aren't object oriented
???

>>57384020
For instance, subtype polymorphism through method overriding is an implementation of dynamic dispatch. Does that make dynamic dispatch bad?

>>57384041
Dynamic dispatch is functional

The fact that an OO feature makes use of it doesn't make it OO

>>57384050
Exactly, retard.

>>57384056
... what?

>>57383994
>>57384003
>>57384018
So no one knows what OOP is?

I sure as hell don't.

>>57384050
>OO is functional
Is your brain functional?

>>57384008
>encapsulation is bad

>>57384066
Dynamic dispatch is making use of higher order functions

>>57384070
Higher order functions are an instance of dynamic dispatch, just like how method overriding is. That is not the definition of dynamic dispatch.

> ITT
> /dpt/ trying to explain what OOP is.

>>57384080
Dynamic dispatch in the strict OOP sense is an instance of a higher order function, not the other way around.

>>57384085
Poo in the loo

>>57384089
Why do you say that?

You're making a point for how OOP doesn't really fit our procedural/functional architectures, but imagine an object-oriented CPU.

>>57383555
>I beat you, therefore you won
This is Canadian arguing

>>57384085
>Liking something you can't explain
>Hating something you can't explain

Literally everyone in this thread talking about OOP is retarded, whether they're in favor or against.

>>57384102
Because it's a function that selects a function to call

>>57384085
>>57384109
Especially you two

>>57383960
Yep.
Sources are available and it's shit.
https://github.com/nginx/nginx

It's only fast thanks to epoll and kqueue.

>>57384115
Again, you're assuming how the OOP is implemented here.

You're correct in practice but not in theory.

File: 668f8459f0132abfa8cbedabe9586f00.jpg (12KB, 300x168px) Image search: [Google]

12KB, 300x168px

>>57384085
I bet no one here can even explain polymorphism. And I will know /g/ if you'd googled it.

>>57384115
>not being ambivalent towards OOP

It's the only reasonable stance.

>>57384124
>you're assuming how the OOP is implemented here.
No, that is literally what it is.
It is dynamically choosing what function to call

>>57384105
>I'm using an irrelevant idiotic metaphor, therefore I won
This is an human arguing

>>57381673
How do I learn more about pic related? Preferably books.

>>57384133
What function? Objects respond to messages and send them out. Theoretically.

>>57384144
>I'm right you are wrong and here is why
This is arguing

>>57384146
Yes, and messages necessarily correspond to functions or procedures

>>57384155
In practice.

>>57384146
>>57384155
or at the very least, one could easily consider higher order messages to be functional

literally the only way to disagree is arguing semantics

>>57384158
No, by necessity if you want a general purpose programming language

>>57384145
go to a good uni and study CS.

>>57384165
In fucking practice given our CPU architectures.

My point is that theoretically, dynamic dispatch is not necessarily anything to do with higher-order functions, so it is not a functional thing specifically that OOP is emulating but rather a more general concept.

>>57384187
No, and it's certainly less general than higher order functions.

>>57384165
yeah, well, one could easily fuck your mom

File: rate.png (119KB, 612x679px) Image search: [Google]

119KB, 612x679px

hi

>>57384165
>>57384187
Also
>higher order messages
What? Different objects may respond differently to the same message. If that decision is made dynamically, it's dynamic dispatch.

Dynamic dispatch COULD also be implemented, not by method overriding (which is basically always implemented using closures), but by having the superclass combine all the subclass methods into one method that branches over the particular subclass. There's a counterexample for you.

>>57384215
Dynamic dispatch is more general than higher order functions in the abstraction sense but less general than higher order functions in the power sense. That's basic parametricity.

>>57384229
Embarassing.

>>57384233
>Dynamic dispatch COULD also be implemented, not by method overriding (which is basically always implemented using closures), but by having the superclass combine all the subclass methods into one method that branches over the particular subclass. There's a counterexample for you.

it's still a higher order function
i'm not talking about the actual fucking implementation, i'm talking about the concept, which selects a function or procedure or message from a collection thereof

>>57384229
>>>/global/rules/2

>>57384248
e.g. in a functional language, case itself, not a specific use of it

e.g. the eliminator for maybes

maybe :: b -> (a -> b) -> (Maybe a -> b)

File: cpp.jpg (230KB, 1280x600px) Image search: [Google]

230KB, 1280x600px

Since C++ is the best language ever made, what's your sorry excuse for not using C++?

>>57384248
A higher order function is a function with a function as an input or output. It is an instance of dynamic dispatch (or static dispatch, considering inlining) because the process of selecting the procedure to call is done by passing it as an argument.

You can make an equivalence between all of these things but that's the whole idea of a general concept that marries them.

>>57384263
Good for you, you know an example of a higher order function.

File: C++.png (54KB, 972x259px) Image search: [Google]

54KB, 972x259px

>>57384277

>>57384277
>C++ is the best language ever made
In what context?

>>57384291
>A higher order function is a function with a function as an input or output. It is an instance of dynamic dispatch (or static dispatch, considering inlining) because the process of selecting the procedure to call is done by passing it as an argument.
>You can make an equivalence between all of these things but that's the whole idea of a general concept that marries them.

The inputs are the overrides and the output is a function from the base type to another type

>>57384277
I use a superior language called D.

>>57384310
You don't seem to understand the difference between an idea and an example.

>>57384277
too complicated to learn. I don't need that kind of performance for anything I'm interested in. C++ sounds pretty great though. Arguable to best langugae for getting shit done in the widest possible variety of problems, if you can git gud at it.

>>57384277
Why are you saying something as retarded as your pick?

>>57381673

I think I really fucked openGL up

I wrote code to generate a set of points seperately from my OpenGL setup code, and it works by itself.

However when I copy and paste it into a project with some basic setup OpenGL shit (compile shaders, define vertex atributes), it prints out garbage.

>>57384318
D is better most of the time.

>>57384333
Wasted

>>57384333
why?

>>57384318
>too complicated to learn
It's just like C# and Java with pointers. STL is the best thing ever to happen to C++

File: Screenshot from 2016-11-04 18-32-48.png (1MB, 1621x1048px) Image search: [Google]

1MB, 1621x1048px

I'm making a frontend for the opencv create sample. Want to train my object detector on semen demons

>>57384347
C# and Java are pretty simple langugaes by comparison with C++. From what I hear C++ has decades of fucking cruft that just keeps getting added on. The amount of stuff you need to learn to be able to read any kind of C++ code and not come across syntax you don't understand seems immense by most langugaes standard.

>>57384347
>C++
>like C#

"no"

>>57384343
Look at the features and examples.
You can do RAII stuff, it's a bit tricky though.

You also got a GC which can be tamed.

Plus cool template stuff and it's less bloated (no 3 different syntax).

So unless you do something truly constrained or have a very good reason to use Sepples, it's worth to take a look at D.

Look at this too:
https://p0nce.github.io/d-idioms/

>>57384372
What's the difference in modern C++ and C#?

I'm implementing a subset of Lisp and need a funny or witty name.

>>57384383
None, it's basically comparing shit and poop

>>57384417
Lu-lu-lisp

>>57384417
lithp

Is there any reason to ever study x86 assembly?

>>57384417
Lip :()

Oh, I still can write programs in the accursed one!

#include <iostream>
#include <set>
#include <cstdlib>

static const std::set<char> \
vowel_set = { 'a', 'e', 'u', 'i', 'o',
          'A', 'E', 'U', 'I', 'O' };
static inline bool is_vowel(char ch)
{
  return vowel_set.count(ch);
}
static bool vowel_eq(const std::string& s1,
             const std::string& s2)
{
  auto size1 = s1.size();
  if (size1 != s2.size())
    return false;
  for (auto i = 0; i < size1; i++)
    if ((is_vowel(s1[i]) || is_vowel(s2[i])) && s1[i] != s2[i])
      return false;
  return true;
}

int main(int ac, char *av[])
{
  std::string s1, s2;
  std::cout << "s1 = " << std::flush;
  std::cin >> s1;
  std::cout << "s2 = " << std::flush;
  std::cin >> s2;
  std::cout << "is_vowel s1 s2 = "
        << (vowel_eq(s1,s2) ? "true" : "false")
        << std::endl;
  return 0;
}

>>57384434
Compilers are shit, it's just that most people are shittier.

Hell, most "programmers" don't even know how their language's runtime works at all.

>>57384434
If you were writing a native compiler I suppose you'd have to be pretty familiar with assembly?

>>57384383
I'm not going to be assed to list everything, but massive swaths of satisfying syntax sugar and managed code by default come to mind. Other language features like LINQ (not sure how much of this C++ can utilize).

Proper Xamarin, Unity, and UWP support
Massive resource investment by Microsoft (most of their devdiv resources are going into C# and things in that ecosystem)

I'm not saying that C++ can't perform these tasks or support them, but C# is the first-class citizen here.

redpill me on Scala, anons

>>57384479
utter garbage

>>57384479
Why don't you go back to >>>/pol/?

>>57384482
What is garbage about it? Attempting to straddle two paradigms?

>>57384434
Not really. The only time you'd ever write assembly for desktop/server applications would be if there were a bug in your compiler that you had to bypass. Chances are, you'll never encounter such a bug. Anyone who says "optimization" is an idiot, shit hasn't been true for decades, compilers do optimizations that nobody would reasonably expect to implement manually.

>>57384483
That makes no sense to me

>>57384499
https://www.youtube.com/watch?v=uiJycy6dFSQ

>>57384501
So you don't want to actually know how shit works.

No one should ever touch a computer who doesn't know assembly at least on a basic level.

>>57384501
>Anyone who says "optimization" is an idiot, shit hasn't been true for decades, compilers do optimizations that nobody would reasonably expect to implement manually.
But that's fucking wrong, you retard!

>c++ doesn't alert to memory leaks
Why?

>>57384549
>what is modern C++

>>57384549
You don't pay for what you don't use.

Get valgrind.

>>57384499
>why don't we take a good paradigm and mix it with a shitty paradigm?
>why don't we take a good language and mix it with a shitty language?

scala explained

>>57384479
It's terrible
https://www.youtube.com/watch?v=uiJycy6dFSQ

>>57384549
>-fsanitize=leak
What are you talking about?

>>57384501
Just because you wouldn't write the damn thing yourself doesn't mean it's not good to know how to read the output.

>>57384582
No, OCaml and F# do this really well. Scala shits itself spectacularly.

>>57384601
F# is shit

>>57384601
How exactly does OCaml fit that description? Also, C# isn't a shitty language and F# isn't all that great.

>>57384610
no

>>57384616
OCaml is imperative+OOP+functional, like F#

>C# isn't a shitty language and F# isn't all that great.
C# is great, F# is more great

>>57384673
>OCaml is imperative+OOP+functional
It's funny that you believe this

OCaml is hardly OOP, and nothing about functional demands purity or declarativitiy

>>57384683
>I like this language but don't like OOP so I'll just let cognitive dissonance takeover and insulate my fragile state of mind.

>>57384673
OCaml does OOP well, though. It doesn't mix ML with some OO cargo cultist language, it adds OOP to ML tastefully.

OCaml also isn't really imperative, it's just not pure functional.

>>57384700
Well, i mean it supports imperative and OOP. Doesn't particularly encourage either of those, but makes it comfy enough to do if you really feel you need it.

>>57384689
Where are the arguments?

>>57384713
Imperative programming is not nearly the same kind of thing as object-oriented programming.

Imperative programming in a declarative language is just something like nested lets, do notation, CPS, etc. where there's any notion of sequence.

OOP is this heavyweight school of thought.

>>57384732
>Imperative programming is not nearly the same kind of thing as object-oriented programming.
Nobody said that freindo

>>57384740
You're putting them on the same level.
>OCaml is imperative+OOP+functional
Functional is comparable to object-oriented, imperative is comparable to declarative.

>>57384732
>OOP
>heavyweight school of thought

If OOP were heavyweight then you wouldn't be referring to structs, whose types act as namespaces, as objects

>>57384778
You can interpret a struct as an object but they sure as hell aren't object-oriented.

>>57384755
>OCaml is declarative+imperative+OOP+functional
good? I would have imagined functional was inclusive of declarative..

>>57384791
Not necessarily.

>>57384783
Structs that act as namespaces is all objects are in C++ and ocaml

>>57384821
So?

>>57384829
So you're saying there isn't actually OOP in ocaml or C++?

how do i tell if i'm oop

>>57384848
check if your first name in Pajeet

>>57384843
No, I'm saying that just because something lightweight can be used as an object doesn't make OOP lightweight in its entirety.

I didn't mean in terms of performance, I meant in terms of scope.

O(n^2 * !n) amortizes to O(n^2) right?

>>57384872
Are you trolling?
O(n^2 * n!) is just O(n!) ...

isXEven ? isYEven ? Brushes.Black : Brushes.White : isYEven ? Brushes.White : Brushes.Black

>>57384889
oh yeah this is true.
I can just throw in an int like 5 and check which value is higher right? does that always work for amortization?
new to this shit, learning babby stuff

>>57384923
do it for a few

>>57384919

isXEven == isYEven ? Brushes.Black : Brushes.White

>>57384923
>I can just throw in an int like 5 and check which value is higher right? does that always work for amortization?
Okay, what you're saying doesn't make any sense.
Amortization is generally something that happens when you occasionally have to do an expensive operation, since most of the time you don't need to do the expensive thing, it's said to be amortized.

>new to this shit, learning babby stuff
I recommend you learn the MATH.

>>57384923
what do you mean by amortization
usually i take that to involve a careful accounting of the individual steps of an algorithm

>>57384923
>>57384940
for instance
n! - n^2 goes negative for a few n's before going positive forever

>>57384944
Not the same.

>>57384966
That doesn't matter, big-O only cares about what happens towards infinity.

>>57384981
Yes, it is.

>>57384983
No, i'm telling him he can't just try 1 number

>>57384994
Oh.

Neat.

>>57384889
>O(n^2 * n!) is just O(n!) ...
What is wrong with your math?

>>57384966
good point thanks anon.
what about n^n, does that ever show itself in algos? any examples?
I know O(1) is best case, so what is worst case aside from infinite?

>>57385010
Well, the worst case would be non-termination, in which case algorithmic complexity isn't even defined.

>>57385004
in big-O it is

>>57385004
That's the definition of big O.

If your algorithm is O(n^2 * n!), then it's just O(n!) because n^2 = O(n!).
And to add to the fun, if your algorithm is O(n), then technically it's also O(n^2) and it's also O(n^2 * n!), but if your algorithm is O(n!) then it might not be O(n^2)!

Simple.

>>57385034
isn't non-termination basically same thing as infinite? I mentioned aside from that for a reason.

File: slow and steady snek.png (31KB, 778x219px) Image search: [Google]

31KB, 778x219px

>>57385010
>what is worst case
there is no worst case, you can always make something slower

>>57385041
>If your algorithm is O(n^2 * n!), then it's just O(n!) because n^2 = O(n!).
i think you want to be more careful with this line

>>57385048
Strictly speaking, it's not correct to say that. It is intuitive though.

>>57385065
You're going to call me out on my math's rigorousness in a thread where people try to determine if f(x)=O(g(x)) by comparing f(5) and g(5) ?

>>57385048
>>57385078
But aside from non-terminating, no, there is no worst case.

It's like how there is no biggest number. Infinity is an intuitive answer but it is not, strictly speaking, a number.

>>57385086
i am only worried that anon will use this line of reasoning to convince himself that, say, O(n^2) = O(n)

>>57385105
Fair enough, my bad.

>>57385038
>>57385041
What kind of non-sense is it?
I'd be happy to see such a positive constant C, that n^2*n! <= Cn! (n^2 <= C) for every n starting from some N.
Neither growth orders are closed under multiplication.

>>57385095
*not a complex number

File: 1423021740668.jpg (15KB, 306x325px) Image search: [Google]

15KB, 306x325px

>>57385078
>>57385095
man infinite is fucking weird

File: 1433034506318.png (75KB, 200x174px) Image search: [Google]

75KB, 200x174px

>>57385041
what the fuck please explain

>>57385121
I should have specified natural number, I suppose, since that's what you deal in when measuring algorithmic complexity.

Also, O(n!) and O((n+1)!) are different.

>>57385117
>What kind of non-sense is it?
Yeah I fucked up, I somehow though that multiplication was an addition..

>>57385117
it is troubling that n^2 n! / n! = n^2 does not go to zero...

>>57385135
https://www.youtube.com/watch?v=80fbdQBwbO4

yup

>>57385166
what does O( (n+1)! * (n+2)!) become?
O((n+2)!) ?

>>57385182
sorry, not zero; a finite number. in my defense i'm an algebraist

>>57385195
>i'm an algebraist
I bet you use Haskell, too

>>57385201
>inb4 he doesn't
why not?

>>57385210
Academia is a strange world.

>>57385194
It stay as it is. You can rewrite it as O(n(n+1)!^2), if you like.

>>57385201
macaulay2 is my best option usually

File: 1476876682254.png (204KB, 500x500px) Image search: [Google]

204KB, 500x500px

O(fib slow!!!!!!!!!!!)

>>57385259
I'm currently rewriting the Linux kernel in Coq.

>>57385237
>You can rewrite it as O(n(n+1)!^2), if you like.
I don't know why anyone should like that, it just sounds terrifying.
You have to try pretty hard to make an algorithm that bad.

>>57385135
You don't know the start of it
https://www.youtube.com/watch?v=SrU9YDoXE88

new thread
>>57385305

>>57385309
Anon you should understand that that's not the point.

>>57385309
That's easy. You can just use counting up to n(n+1)!^2.

>>57385345
I think that counts as trying pretty hard.

>>57384430
>lithp

that is genuinly funny, thanks.

File: YostubaYotsuba.png (286KB, 763x561px) Image search: [Google]

286KB, 763x561px

>>57385405
You're welcome.

File: 1474778268681.gif (18KB, 125x125px) Image search: [Google]

18KB, 125x125px

Amortized time doesn't necessarily have to talk about "tending towards infinity".
IIRC the exact definition is: "f(N) ∈ O(g(N))" if there exists some 'n', and some positive 'c' such that f(x) ≤ c*g(x) for all x ≥ n

Some examples:
Proposition: N ∈ O(N^2)
Proof: let c=1.
f(x) - c*g(x) = x - x^2 = x(1-x)
It's trivial to show than x(1-x) ≤ 0 for all x ≥ 1, so we can then let n=1 and we have proven the above.

Proposition: for all positive k, k*f(N) ∈ O(f(N))
We simply let c=k, which gives us
k*f(x) ≤ k*f(x), trivially true for all x.

In neither of the above cases to we talk about limits or "tending to infinity"

>>57385405
>>57385445
already taken though https://esolangs.org/wiki/LITHP

>>57385600
It's just a joke language though, doesn't have an actual implementation or specification.

Make it real, anon.

Is Rust actually good or is it just a meme language?

MO
͏ ͏͏ ͏DE
͏ ͏͏ ͏͏ ͏ ͏RN
͏ ͏͏ ͏͏ ͏ ͏͏ ͏͏ ͏͏͏C
͏ ͏͏ ͏͏ ͏ ͏͏ ͏͏ ͏͏͏͏ ͏͏͏ ͏++
͏ ͏͏ ͏͏ ͏ ͏͏ ͏͏ ͏͏͏C
͏ ͏͏ ͏͏ ͏ ͏RN
͏ ͏͏ ͏DE
MO

File: aeofpqsdkpqd.png (45KB, 824x607px) Image search: [Google]

45KB, 824x607px

>>57385148

>>57386025
Can't figure out what fucked up scale you used for the y axis

>>57386052
http://bigocheatsheet.com/