Would you be able to verify that CUDA's working by running the sample programs (detailed here?)
pip3 install torch==1.3.1+cu92 torchvision==0.4.2+cu92 -f https://download.pytorch.org/whl/torch_stable.html
C++ has changed a lot over the years. More traditional C++ programming has much of the same problems as C. And of course there's the old C++ FQA if you want to read some pretty accurate criticisms of past versions of C++ (by someone with a *lot* of time on their hands).
Hmm, Forth might be competitive. Forth is really fascinating.
I program professionally, so I approach these issues from a different perspective. I approach them from the perspective of getting something done while expending less resources. And the most costly resource is my time.
This brings up a question I'd like to throw to the wider audience - when do you get to call yourself a Senior Developer on your CV / Linkdin?
You can always use Golang and hate life. It's depressing to use.
Security bugs in C software flow one way: from writing the software to using the software. No knowledge of C changes running the software.
If you want to find out what still sets Ocaml and SML apart in the world of typed functional programming, look into its module system, which, out of every approach to modular programming I have used, is hands down the best (assuming you care about static type-safety).
You know the saying "if you make something idiot proof, someone will make a better idiot"?
Oh totally. Their module/type systems are top notch. Shit like functors.
You said that knowing C is important because everything is written in it. But that's untrue. You can use apache and nginx and the linux kernel without knowing C. Not knowing C doesn't affect your ability to use them securely.
I really like how it approaches error handling. Javascript's use of exceptions makes me want to tear my hair out.
It's always cool when people implement Category Theory concepts. If you're ever curious there are two Clojure libraries which have also done that: Cats (geddit?) and fluokitten (starting to think felines are a theme here).
Seems like a pretty obvious choice between the two. I won't deny the retarded little gopher can go, or that the language isn't pleasant, in the way pastel colors are. I might have even enjoyed it had I found it years ago, but as to where I am now, it just sucks ass to write in. I can die of the sheer boredom. At least C has the excitement of the chance you fucked yourself royally.
I'd be interested in hearing more of your needs here. I'd think you could do near enough everything you want of a plugin architecture with ordinary modules. What you couldn't do is have modules computed at runtime and hotloaded, but I'm not sure if first-class modules can do that anyway (though I am currently using them in exactly this way, hotloading new implementations into a TCP server from the toplevel).
It's not category theory in this case. "Functor" is badly overloaded in programming. Prolog always used it to refer to the head symbol in a structured term, which happens to be the closest usage to Carnap's, who originally coined the term. C++ programmers use "functor" to refer to objects which implement the "()" operator. Ocaml and SML use "functor" to refer to functions of modules.
Y'know who Rob Pike had in mind for his target market of idiots? Fucking Googlers.
open Core
module Let_syntax = struct
let bind _ _ = failwith "debug finish"
end
type payload = string
module type PROTOCOL = sig
type conn
val open_connection : string -> (conn, Error.t) Lwt_result.t
val pull : conn -> (payload, Error.t) Lwt_result.t
val push : conn -> payload -> (unit, Error.t) Lwt_result.t
val close : conn -> (unit, Error.t) Lwt_result.t
end
module RTMP : PROTOCOL = struct
(* ... etc *)
end
module HLS : PROTOCOL = struct
(* ... etc *)
end
module MPEGDASH : PROTOCOL = struct
(* ... etc *)
end
let protocols = [
"rtmp", (module RTMP : PROTOCOL)
;"hls", (module HLS : PROTOCOL)
;"mpeg-dash", (module MPEGDASH : PROTOCOL)
]
let stream (src_protocol, src_addr) (dst_protocol, dst_addr) =
let (module Src_protocol) = List.Assoc.find_exn protocols ~equal:(=) src_protocol in
let (module Dst_protocol) = List.Assoc.find_exn protocols ~equal:(=) dst_protocol in
let%bind src = Src_protocol.open_connection src_addr in
let%bind dst = Dst_protocol.open_connection dst_addr in
let rec iter () =
(* I should probably do something more complicated to close the other
connection in the case of any errors... but this is good enough for
this example *)
let%bind payload = Src_protocol.pull src in
let%bind () = Dst_protocol.push dst payload in
iter ()
in
iter ()
You better believe it!
Incidentally, can you smell the cumin and coriander wafting from this part of the quote?
Since there are only nine combinations, you could make stream a functor of its source and destination protocols, and then define nine stream functions in terms of the Stream functor, each with the appropriate one-liner. Better would be to find a way to get the choice into your build configuration, if protocol choice is possible to know before runtime. But if you want to stick with the more dynamic approach, you could replace your protocol module with a record type:
type conn =
{ pull : unit -> (payload, Error.t) Lwt_result.t
; push : payload -> (unit, Error.t) Lwt_result.t
; close : unit -> (unit, Error.t) Lwt_result.t }
val open_connection : string -> (conn, Error.t) Lwt_result.tlet open_connection prot str =
match prot with
| "rtmp" ->
let open RTMP in
let%bind conn = open_connection str in
let pull () = pull conn in
let push = push conn in
let close () = close conn in
Lwt_result.return {pull; push; close} )