{"id":20291,"date":"2024-03-20T21:38:31","date_gmt":"2024-03-20T21:38:31","guid":{"rendered":"https:\/\/fortran.uk\/?page_id=20291"},"modified":"2024-04-04T18:08:29","modified_gmt":"2024-04-04T17:08:29","slug":"isfortranmemorysafe","status":"publish","type":"page","link":"https:\/\/fortran.uk\/isfortranmemorysafe\/","title":{"rendered":"Is Fortran \u201cMemory Safe\u201d?"},"content":{"rendered":"

A recent report<\/a> from the White House Office of the National Cyber Director highlights the need for \u201cMemory-Safe\u201d computer languages and tools. Cybersecurity is a major driver for this initiative, and it\u2019s undeniable that innumerable malicious exploits have targeted\u00a0 dangling pointers and buffer over-runs to steal data or subvert critical systems. However, productivity also suffers badly when memory errors cause hang-ups, blue-screens, and other erratic and non-reproducible behaviours. Bugs like this are deeply frustrating for end-users, and notoriously difficult to debug.<\/p>\n

Fortran is not immune to these problems, though it is less vulnerable than pointer-based languages.\u00a0 Fortran does have a restricted form of pointers, but for most applications, allocatable arrays provide a flexible and memory safe alternative. Unlike pointer arrays, allocatable arrays cannot leak memory or leave dangling references.<\/p>\n

The table below shows how some current compilers deal with common memory-safety errors.\u00a0 It shows that Fortran can be memory-safe, but that compilers that excel for execution speed may trail in diagnostics, and vice versa.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Source<\/strong><\/td>\nRun-time Error<\/strong><\/td>\nSilverfrost<\/strong><\/td>\ngfortran<\/strong><\/td>\nIntel IFX<\/strong><\/td>\nnvFortran<\/strong><\/td>\nNAG<\/strong><\/td>\n<\/tr>\n
<\/td>\n<\/td>\nftn95 9.0<\/strong><\/td>\n12.3.0<\/strong><\/td>\n2024.0.2<\/strong><\/td>\n24.3<\/strong><\/td>\n7.1<\/strong><\/td>\n<\/tr>\n
<\/td>\nPercentage Passes1<\/sup><\/td>\n94%<\/td>\n48%<\/td>\n54%<\/td>\n35%<\/td>\n96%<\/td>\n<\/tr>\n
<\/td>\nAERMOD.f90 execution time with diagnostic switches (seconds)2<\/sup><\/td>\n86<\/td>\n20<\/td>\n29<\/td>\n19<\/td>\n127<\/td>\n<\/tr>\n
<\/td>\nAERMOD.f90 execution time optimized (seconds)2<\/sup><\/td>\n11<\/td>\n10<\/td>\n3<\/td>\n5<\/td>\n8<\/td>\n<\/tr>\n
<\/td>\nCan mix checked and unchecked code<\/td>\nYes<\/td>\nYes<\/td>\nYes<\/td>\nYes<\/td>\nNo<\/td>\n<\/tr>\n
<\/td>\nFull trace-back from run-time errors<\/td>\nYes<\/td>\nNo<\/td>\nYes<\/td>\nYes<\/td>\nYes<\/td>\n<\/tr>\n
ARG1<\/a><\/td>\nArgument mismatch \u2013 same file<\/td>\nYes5<\/sup><\/td>\nYes4<\/sup><\/td>\nYes4<\/sup><\/td>\nNo<\/td>\nYes4<\/sup><\/td>\n<\/tr>\n
ARG2<\/a><\/td>\nArgument mismatch \u2013 different file6<\/sup><\/span><\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nYes4,8<\/sup><\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
ARG3<\/a><\/td>\nIllegal assignment to constant argument \u2013 no INTENT specified<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nYes5,9<\/sup><\/td>\nYes5,9<\/sup><\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
ARG4<\/a><\/td>\nIllegal assignment to constant argument \u2013 INTENT specified<\/td>\nYes4<\/sup><\/td>\nYes4<\/sup><\/td>\nYes4<\/sup><\/td>\nYes3,5,9<\/sup><\/td>\nYes4<\/sup><\/td>\n<\/tr>\n
ARG5<\/a><\/td>\nIllegal assignment to DO loop variable in SUBROUTINE \u2013 no INTENT specified<\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
ARG6<\/a><\/td>\nIllegal assignment to DO loop variable in SUBROUTINE \u2013 INTENT specified<\/td>\nYes4<\/sup><\/td>\nYes4<\/sup><\/td>\nYes4<\/sup><\/td>\nYes3<\/sup><\/td>\nYes4<\/sup><\/td>\n<\/tr>\n
ARG7<\/a><\/td>\nScalar constant passed to array dummy argument<\/td>\nYes5<\/sup><\/td>\nYes4<\/sup><\/td>\nYes4<\/sup><\/td>\nNo<\/td>\nYes4<\/sup><\/td>\n<\/tr>\n
OARG1<\/a><\/td>\nIllegal use of optional argument<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nYes5,9<\/sup><\/td>\nYes5,9<\/sup><\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
ALIAS1<\/a><\/td>\nAliased dummy argument variable<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
ALIAS2<\/a><\/td>\nAliased dummy argument array<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\n<\/tr>\n
Source<\/strong><\/td>\nRun-time Error<\/strong><\/td>\nSilverfrost<\/strong><\/td>\ngfortran<\/strong><\/td>\nIntel IFX<\/strong><\/td>\nnvFortran<\/strong><\/td>\nNAG<\/strong><\/td>\n<\/tr>\n
BND1<\/a><\/td>\nArray bound error \u2013 X(100)<\/td>\nYes5<\/sup><\/td>\nYes3,5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
BND2<\/a><\/td>\nArray bound error \u2013 X(N) N is argument<\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
BND3<\/a><\/td>\nArray bound error \u2013 X(N) N is in COMMON<\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
BND4<\/a><\/td>\nArray bound error \u2013 X(N) N is in MODULE<\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
BND5<\/a><\/td>\nAssumed size array bound error \u2013 X(*)<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
BND6<\/a><\/td>\nArray bound error \u2013 X(M:N) M and N argument \u2013 lower bound violated<\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
BND7<\/a><\/td>\nArray bound error \u2013 automatic array<\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
BND8<\/a><\/td>\nArray bound error \u2013 allocatable array<\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
BND9<\/a><\/td>\nMulti-dimensional array bound error within overall array bounds<\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
BND10<\/a><\/td>\nArray bound error \u2013 assign to dummy argument which is larger than actual argument<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
BND11<\/a><\/td>\nArray bound error \u2013 pointer array component of derived type<\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
CBND1<\/a><\/td>\nCharacter bound error \u2013 local<\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
CBND2<\/a><\/td>\nCharacter bound error \u2013 COMMON<\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
CBND3<\/a><\/td>\nCharacter bound error \u2013 assign to dummy which is larger than actual argument<\/td>\nYes5<\/sup><\/td>\nYes3,5<\/sup><\/td>\nYes4<\/sup><\/td>\nNo<\/td>\nYes4<\/sup><\/td>\n<\/tr>\n
CBND4<\/a><\/td>\nCharacter bound error \u2013 CHARACTER*(*)<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
Source<\/strong><\/td>\nRun-time Error<\/strong><\/td>\nSilverfrost<\/strong><\/td>\ngfortran<\/strong><\/td>\nIntel IFX<\/strong><\/td>\nnvFortran<\/strong><\/td>\nNAG<\/strong><\/td>\n<\/tr>\n
UIN1<\/a><\/td>\nUninitialized variable7<\/sup>\u00a0\u2013 local<\/td>\nYes3,5<\/sup><\/td>\nYes3<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nYes3,5<\/sup><\/td>\n<\/tr>\n
UIN2<\/a><\/td>\nUninitialized variable \u2013 argument<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
UIN3<\/a><\/td>\nUninitialized variable \u2013 COMMON<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
UIN4<\/a><\/td>\nUninitialized variable \u2013 MODULE<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
UIN5<\/a><\/td>\nUninitialized array element \u2013 local<\/td>\nYes5<\/sup><\/td>\nNo3<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
UIN6<\/a><\/td>\nUninitialized array element \u2013 argument<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
UIN7<\/a><\/td>\nUninitialized array element \u2013 COMMON<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
UIN8<\/a><\/td>\nUninitialized array element \u2013 MODULE<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
UIN9<\/a><\/td>\nUninitialized array element \u2013 local array in SUBROUTINE<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
UIN10<\/a><\/td>\nUninitialized array element \u2013 automatic arrays<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
UIN11<\/a><\/td>\nUninitialized array element \u2013 allocatable arrays<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
UIN12<\/a><\/td>\nUninitialized array element \u2013 saved arrays<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
UIN13<\/a><\/td>\nUninitialized array element \u2013 INTENT(OUT) arrays<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
UIN14<\/a><\/td>\nTwo byte array elements<\/td>\nNo10<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
UIN15<\/a><\/td>\nOne byte array elements<\/td>\nNo10<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
Source<\/strong><\/td>\nRun-time Error<\/strong><\/td>\nSilverfrost<\/strong><\/td>\ngfortran<\/strong><\/td>\nIntel IFX<\/strong><\/td>\nnvFortran<\/strong><\/td>\nNAG<\/strong><\/td>\n<\/tr>\n
DO1<\/a><\/td>\nZero increment DO loop<\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5,9<\/sup><\/td>\nYes5,9<\/sup><\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
DO2<\/a><\/td>\nIllegal assignment to local DO loop variable<\/td>\nYes4<\/sup><\/td>\nYes4<\/sup><\/td>\nYes4<\/sup><\/td>\nYes3<\/sup><\/td>\nYes4<\/sup><\/td>\n<\/tr>\n
DO3<\/a><\/td>\nIllegal assignment to local DO loop variable via EQUIVALENCE<\/td>\nYes3,5<\/sup><\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nYes4<\/sup><\/td>\n<\/tr>\n
DO4<\/a><\/td>\nIllegal assignment to DO variables in CONTAINed subprogram<\/td>\nYes5<\/sup><\/td>\nYes4<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
SF1<\/a><\/td>\nSUBROUTINE referenced as a FUNCTION \u2013 same file<\/td>\nYes5<\/sup><\/td>\nYes4<\/sup><\/td>\nYes4<\/sup><\/td>\nYes4<\/sup><\/td>\nYes4<\/sup><\/td>\n<\/tr>\n
SF2<\/a><\/td>\nSUBROUTINE referenced as a FUNCTION \u2013 different file6<\/sup><\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nYes5,9<\/sup><\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
FMT1<\/a><\/td>\nIllegal run-time format<\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
CONF<\/a><\/td>\nNon-conformant array assignment<\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
PTR1<\/a><\/td>\nAssign via pointer after target deallocated<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
PTR2<\/a><\/td>\nAssign via global pointer to local array after subprogram return<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nYes5,9<\/sup><\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
IOFL<\/a><\/td>\nInteger overflow<\/td>\nYes5<\/sup><\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes5<\/sup><\/td>\n<\/tr>\n
LEAK<\/a><\/td>\nGarbage collection<\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nNo<\/td>\nYes11<\/sup><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n\n\n\n\n\n\n\n\n
Compiler Switches<\/strong><\/span><\/td>\n<\/tr>\n
Silverfrost FTN95 9.0<\/td>\nftn95 \/full_undef \/check_alias<\/td>\n<\/tr>\n
gfortran 12.3.0<\/td>\ngfortran -fcheck=all -Wall -Waliasing -pedantic -fbacktrace\u00a0 -g<\/td>\n<\/tr>\n
Intel IFX 2024.0.2<\/td>\nifx \/check:all \/fpe:0 \/traceback \/warn:all,nodec,noexternals \/auto \/Od \/gen-interfaces \/warn-interfaces \/Qtrapuv \/Qansi-alias \/link \/stack:1000000<\/td>\n<\/tr>\n
NAG 7.1<\/td>\nf95 -C=all -C=undefined -info<\/td>\n<\/tr>\n
nvFortran 24.3<\/td>\nnvfortran -g -Mbounds -Mchkstk -Mchkptr -Minform=inform -C -traceback<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Notes<\/strong><\/span><\/td>\n<\/tr>\n
<\/td>\nThanks to Herman D. Knoble and Arnaud Desitter for supplying some of the diagnostic tests.<\/td>\n<\/tr>\n
<\/td>\nAll tests were run using Windows 11 on an ASUS laptop with AMD Ryzen 7 6800U processor and 16GB RAM. In the case of nvfortran, the tests were run using WSL (Windows Subsystem for Linux)..<\/td>\n<\/tr>\n
1<\/td>\n“Percentage Passes” is calculated from a total of 54 tests.<\/td>\n<\/tr>\n
2<\/td>\nExecution Time for AERMOD.f90 benchmark, compiled using the diagnostic switches (see table above) or with somewhat optimized settings (indicative only).<\/td>\n<\/tr>\n
3<\/td>\nCompiler issued warning message.<\/td>\n<\/tr>\n
4<\/td>\nCompiler issued fatal error message – no executable produced.<\/td>\n<\/tr>\n
5<\/td>\nRun-time message.<\/td>\n<\/tr>\n
6<\/td>\nArranged so that error is not visible at compile time.<\/td>\n<\/tr>\n
7<\/td>\nA variable is “uninitialized” if it has never been assigned a value. Data elements should be initialized before their value is used. The illegal use of an uninitialized variable can sometimes be detected at compile-time, but, because it may be data and flow dependent, usually requires run-time monitoring. In some cases, compilers implement this by checking for a special “uninitialized” bit pattern, such as 0x80, but this may result in false positives for one or two byte variables (and, rarely, in other cases). Use of a “shadow array” doubles memory requirements, but avoids false positives.<\/td>\n<\/tr>\n
8<\/td>\nCompilation order dependent. Compiler generates .mod file to allow interface checking.<\/td>\n<\/tr>\n
9<\/td>\nNon-specific error message, but full traceback.<\/td>\n<\/tr>\n
10<\/td>\nFalse positive was reported at run time.<\/td>\n<\/tr>\n
11<\/td>\nFortran programs that use pointers to allocate arrays and structures can leak memory, unless the programmer takes care to ensure the memory is freed before it becomes inaccessible.. An automated garbage collector may retrieve leaked memory.\u00a0 The Linux NAG Fortran compiler has a garbage collection option, but we have not tested it.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Download source code of tests<\/a><\/strong><\/p>\n

Compiler Comparisons (last updated 2017)<\/a><\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"

A recent report from the White House Office of the National Cyber Director highlights the need for \u201cMemory-Safe\u201d computer languages and tools. Cybersecurity is a major driver for this initiative, and it\u2019s undeniable that innumerable malicious exploits have targeted\u00a0 dangling pointers and buffer over-runs to steal data or subvert critical systems. However, productivity also suffers […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":[],"yoast_head":"\nIs Fortran \u201cMemory Safe\u201d? - Fortran UK<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/fortran.uk\/isfortranmemorysafe\/\" \/>\n<meta property=\"og:locale\" content=\"en_GB\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Is Fortran \u201cMemory Safe\u201d? - Fortran UK\" \/>\n<meta property=\"og:description\" content=\"A recent report from the White House Office of the National Cyber Director highlights the need for \u201cMemory-Safe\u201d computer languages and tools. Cybersecurity is a major driver for this initiative, and it\u2019s undeniable that innumerable malicious exploits have targeted\u00a0 dangling pointers and buffer over-runs to steal data or subvert critical systems. However, productivity also suffers […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/fortran.uk\/isfortranmemorysafe\/\" \/>\n<meta property=\"og:site_name\" content=\"Fortran UK\" \/>\n<meta property=\"article:modified_time\" content=\"2024-04-04T17:08:29+00:00\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Estimated reading time\" \/>\n\t<meta name=\"twitter:data1\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/fortran.uk\/isfortranmemorysafe\/\",\"url\":\"https:\/\/fortran.uk\/isfortranmemorysafe\/\",\"name\":\"Is Fortran \u201cMemory Safe\u201d? - Fortran UK\",\"isPartOf\":{\"@id\":\"https:\/\/fortran.uk\/#website\"},\"datePublished\":\"2024-03-20T21:38:31+00:00\",\"dateModified\":\"2024-04-04T17:08:29+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/fortran.uk\/isfortranmemorysafe\/#breadcrumb\"},\"inLanguage\":\"en-GB\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/fortran.uk\/isfortranmemorysafe\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/fortran.uk\/isfortranmemorysafe\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/fortran.uk\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Is Fortran \u201cMemory Safe\u201d?\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/fortran.uk\/#website\",\"url\":\"https:\/\/fortran.uk\/\",\"name\":\"Fortran UK\",\"description\":\"All things Fortran\",\"publisher\":{\"@id\":\"https:\/\/fortran.uk\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/fortran.uk\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-GB\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/fortran.uk\/#organization\",\"name\":\"Polyhedron Solutions Ltd.\",\"url\":\"https:\/\/fortran.uk\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-GB\",\"@id\":\"https:\/\/fortran.uk\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/fortran.uk\/wp-content\/uploads\/2018\/03\/Web-logoPolySol.png\",\"contentUrl\":\"https:\/\/fortran.uk\/wp-content\/uploads\/2018\/03\/Web-logoPolySol.png\",\"width\":203,\"height\":113,\"caption\":\"Polyhedron Solutions Ltd.\"},\"image\":{\"@id\":\"https:\/\/fortran.uk\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/www.youtube.com\/@polyhedronsolutions1405\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Is Fortran \u201cMemory Safe\u201d? - Fortran UK","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/fortran.uk\/isfortranmemorysafe\/","og_locale":"en_GB","og_type":"article","og_title":"Is Fortran \u201cMemory Safe\u201d? - Fortran UK","og_description":"A recent report from the White House Office of the National Cyber Director highlights the need for \u201cMemory-Safe\u201d computer languages and tools. Cybersecurity is a major driver for this initiative, and it\u2019s undeniable that innumerable malicious exploits have targeted\u00a0 dangling pointers and buffer over-runs to steal data or subvert critical systems. However, productivity also suffers […]","og_url":"https:\/\/fortran.uk\/isfortranmemorysafe\/","og_site_name":"Fortran UK","article_modified_time":"2024-04-04T17:08:29+00:00","twitter_card":"summary_large_image","twitter_misc":{"Estimated reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/fortran.uk\/isfortranmemorysafe\/","url":"https:\/\/fortran.uk\/isfortranmemorysafe\/","name":"Is Fortran \u201cMemory Safe\u201d? - Fortran UK","isPartOf":{"@id":"https:\/\/fortran.uk\/#website"},"datePublished":"2024-03-20T21:38:31+00:00","dateModified":"2024-04-04T17:08:29+00:00","breadcrumb":{"@id":"https:\/\/fortran.uk\/isfortranmemorysafe\/#breadcrumb"},"inLanguage":"en-GB","potentialAction":[{"@type":"ReadAction","target":["https:\/\/fortran.uk\/isfortranmemorysafe\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/fortran.uk\/isfortranmemorysafe\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/fortran.uk\/"},{"@type":"ListItem","position":2,"name":"Is Fortran \u201cMemory Safe\u201d?"}]},{"@type":"WebSite","@id":"https:\/\/fortran.uk\/#website","url":"https:\/\/fortran.uk\/","name":"Fortran UK","description":"All things Fortran","publisher":{"@id":"https:\/\/fortran.uk\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/fortran.uk\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-GB"},{"@type":"Organization","@id":"https:\/\/fortran.uk\/#organization","name":"Polyhedron Solutions Ltd.","url":"https:\/\/fortran.uk\/","logo":{"@type":"ImageObject","inLanguage":"en-GB","@id":"https:\/\/fortran.uk\/#\/schema\/logo\/image\/","url":"https:\/\/fortran.uk\/wp-content\/uploads\/2018\/03\/Web-logoPolySol.png","contentUrl":"https:\/\/fortran.uk\/wp-content\/uploads\/2018\/03\/Web-logoPolySol.png","width":203,"height":113,"caption":"Polyhedron Solutions Ltd."},"image":{"@id":"https:\/\/fortran.uk\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.youtube.com\/@polyhedronsolutions1405"]}]}},"_links":{"self":[{"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/pages\/20291"}],"collection":[{"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/comments?post=20291"}],"version-history":[{"count":40,"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/pages\/20291\/revisions"}],"predecessor-version":[{"id":20342,"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/pages\/20291\/revisions\/20342"}],"wp:attachment":[{"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/media?parent=20291"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}